def setup_lcd_line(self, display_id, line, device_id, measurement):
self.lcd_line[display_id][line]['setup'] = False
self.lcd_line[display_id][line]['id'] = device_id
self.lcd_line[display_id][line]['name'] = None
self.lcd_line[display_id][line]['unit'] = None
self.lcd_line[display_id][line]['measure'] = measurement
if 'time' in measurement:
self.lcd_line[display_id][line]['measure'] = 'time'
if not device_id:
return
# Determine the unit
if measurement == 'setpoint':
pid = db_retrieve_table_daemon(PID, unique_id=device_id)
if pid:
if pid.measurement.split(',')[1] in self.list_inputs:
self.lcd_line[display_id][line]['unit'] = self.list_inputs[
pid.measurement.split(',')[1]]['unit']
else:
self.lcd_line[display_id][line]['unit'] = ''
elif measurement in self.list_inputs:
# Get what each measurement uses for a unit
input_dev = db_retrieve_table_daemon(Input)
use_unit = use_unit_generate(input_dev)
if (device_id in use_unit and measurement in use_unit[device_id]
and use_unit[device_id][measurement] is not None):
self.lcd_line[display_id][line]['unit'] = UNITS[
use_unit[device_id][measurement]]['unit']
else:
self.lcd_line[display_id][line]['unit'] = self.list_inputs[
measurement]['unit']
else:
self.lcd_line[display_id][line]['unit'] = ''
# Determine the name
controllers = [Output, PID, Input, Math]
for each_controller in controllers:
controller_found = db_retrieve_table_daemon(each_controller,
unique_id=device_id)
if controller_found:
self.lcd_line[display_id][line]['name'] = controller_found.name
if (self.lcd_line[display_id][line]['measure'] == 'time'
or None not in [
self.lcd_line[display_id][line]['name'],
self.lcd_line[display_id][line]['unit']
]):
self.lcd_line[display_id][line]['setup'] = True
def check_func(all_devices, unique_id, y_axes, measurement, dict_measurements,
input_dev):
"""
Generate a list of y-axes for Live and Asynchronous Graphs
:param all Input, Math, Output, and PID SQL entries of a table
:param unique_id: The ID of the measurement
:param y_axes: empty list to populate
:param measurement:
:param dict_measurements:
:param input_dev:
:return: None
"""
# Iterate through each device entry
for each_device in all_devices:
# If the ID saved to the dashboard element matches the table entry ID
if each_device.unique_id == unique_id:
use_unit = use_unit_generate(input_dev)
# Add duration_sec
if measurement == 'duration_sec':
if 'duration_sec' not in y_axes:
y_axes.append('duration_sec')
# Use Linux Command measurement
elif (all_devices == input_dev and each_device.cmd_measurement
and each_device.cmd_measurement != ''
and each_device.cmd_measurement == measurement
and each_device.cmd_measurement not in y_axes):
y_axes.append(each_device.cmd_measurement)
# Use custom-converted units
elif (unique_id in use_unit and measurement in use_unit[unique_id]
and use_unit[unique_id][measurement]):
measure_short = use_unit[unique_id][measurement]
if measure_short not in y_axes:
y_axes.append(measure_short)
# Find the y-axis the setpoint or bands apply to
elif measurement in [
'setpoint', 'setpoint_band_min', 'setpoint_band_max'
]:
for each_input in input_dev:
if each_input.unique_id == each_device.measurement.split(
',')[0]:
pid_measurement = each_device.measurement.split(',')[1]
# If PID uses input with custom conversion, use custom unit
if (each_input.unique_id in use_unit
and pid_measurement
in use_unit[each_input.unique_id] and use_unit[
each_input.unique_id][pid_measurement]):
measure_short = use_unit[
each_input.unique_id][pid_measurement]
if measure_short not in y_axes:
y_axes.append(measure_short)
# Else use default unit for input measurement
else:
if pid_measurement in dict_measurements:
measure_short = dict_measurements[
pid_measurement]['meas']
if measure_short not in y_axes:
y_axes.append(measure_short)
# Append all other measurements if they don't already exist
elif measurement in dict_measurements:
measure_short = dict_measurements[measurement]['meas']
if measure_short not in y_axes:
y_axes.append(measure_short)
return y_axes
def check_func(all_devices,
unique_id,
y_axes,
measurement,
dict_measurements,
device_measurements,
input_dev,
output,
math,
function,
unit=None):
"""
Generate a list of y-axes for Live and Asynchronous Graphs
:param all_devices: Input, Math, Output, and PID SQL entries of a table
:param unique_id: The ID of the measurement
:param y_axes: empty list to populate
:param measurement:
:param dict_measurements:
:param device_measurements:
:param input_dev:
:param output:
:param math:
:param function
:param unit:
:return: None
"""
# Iterate through each device entry
for each_device in all_devices:
# If the ID saved to the dashboard element matches the table entry ID
if each_device.unique_id == unique_id:
use_unit = use_unit_generate(
device_measurements, input_dev, output, math, function)
# Add duration
if measurement == 'duration_time':
if 'second' not in y_axes:
y_axes.append('second')
# Add duty cycle
elif measurement == 'duty_cycle':
if 'percent' not in y_axes:
y_axes.append('percent')
# Use custom-converted units
elif (unique_id in use_unit and
measurement in use_unit[unique_id] and
use_unit[unique_id][measurement]):
measure_short = use_unit[unique_id][measurement]
if measure_short not in y_axes:
y_axes.append(measure_short)
# Find the y-axis the setpoint or bands apply to
elif measurement in ['setpoint', 'setpoint_band_min', 'setpoint_band_max']:
for each_input in input_dev:
if each_input.unique_id == each_device.measurement.split(',')[0]:
pid_measurement = each_device.measurement.split(',')[1]
# If PID uses input with custom conversion, use custom unit
if (each_input.unique_id in use_unit and
pid_measurement in use_unit[each_input.unique_id] and
use_unit[each_input.unique_id][pid_measurement]):
measure_short = use_unit[each_input.unique_id][pid_measurement]
if measure_short not in y_axes:
y_axes.append(measure_short)
# Else use default unit for input measurement
else:
if pid_measurement in dict_measurements:
measure_short = dict_measurements[pid_measurement]['meas']
if measure_short not in y_axes:
y_axes.append(measure_short)
# Append all other measurements if they don't already exist
elif measurement in dict_measurements and not unit:
measure_short = dict_measurements[measurement]['meas']
if measure_short not in y_axes:
y_axes.append(measure_short)
# use custom y-axis
elif measurement not in dict_measurements or unit not in dict_measurements[measurement]['units']:
meas_name = '{meas}_{un}'.format(meas=measurement, un=unit)
if meas_name not in y_axes and unit:
y_axes.append(meas_name)
return y_axes
def check_func(all_devices,
unique_id,
y_axes,
measurement,
dict_measurements,
device_measurements,
input_dev,
output,
math,
unit=None):
"""
Generate a list of y-axes for Live and Asynchronous Graphs
:param all_devices: Input, Math, Output, and PID SQL entries of a table
:param unique_id: The ID of the measurement
:param y_axes: empty list to populate
:param measurement:
:param dict_measurements:
:param device_measurements:
:param input_dev:
:param output:
:param math:
:param unit:
:return: None
"""
# Iterate through each device entry
for each_device in all_devices:
# If the ID saved to the dashboard element matches the table entry ID
if each_device.unique_id == unique_id:
use_unit = use_unit_generate(
device_measurements, input_dev, output, math)
# Add duration
if measurement == 'duration_time':
if 'second' not in y_axes:
y_axes.append('second')
# Add duty cycle
elif measurement == 'duty_cycle':
if 'percent' not in y_axes:
y_axes.append('percent')
# Use custom-converted units
elif (unique_id in use_unit and
measurement in use_unit[unique_id] and
use_unit[unique_id][measurement]):
measure_short = use_unit[unique_id][measurement]
if measure_short not in y_axes:
y_axes.append(measure_short)
# Find the y-axis the setpoint or bands apply to
elif measurement in ['setpoint', 'setpoint_band_min', 'setpoint_band_max']:
for each_input in input_dev:
if each_input.unique_id == each_device.measurement.split(',')[0]:
pid_measurement = each_device.measurement.split(',')[1]
# If PID uses input with custom conversion, use custom unit
if (each_input.unique_id in use_unit and
pid_measurement in use_unit[each_input.unique_id] and
use_unit[each_input.unique_id][pid_measurement]):
measure_short = use_unit[each_input.unique_id][pid_measurement]
if measure_short not in y_axes:
y_axes.append(measure_short)
# Else use default unit for input measurement
else:
if pid_measurement in dict_measurements:
measure_short = dict_measurements[pid_measurement]['meas']
if measure_short not in y_axes:
y_axes.append(measure_short)
# Append all other measurements if they don't already exist
elif measurement in dict_measurements and not unit:
measure_short = dict_measurements[measurement]['meas']
if measure_short not in y_axes:
y_axes.append(measure_short)
# use custom y-axis
elif measurement not in dict_measurements or unit not in dict_measurements[measurement]['units']:
meas_name = '{meas}_{un}'.format(meas=measurement, un=unit)
if meas_name not in y_axes and unit:
y_axes.append(meas_name)
return y_axes
def add_custom_measurements(inputs, maths, measurement_units):
"""
Returns the measurement dictionary appended with
input, ADC, and command measurements/units
"""
return_measurements = measurement_units
use_unit = use_unit_generate(inputs)
for each_input in inputs:
# Add command measurements/units to measurements dictionary
if (each_input.cmd_measurement and each_input.cmd_measurement_units
and each_input.cmd_measurement not in measurement_units):
return_measurements.update({
each_input.cmd_measurement: {
'meas': each_input.cmd_measurement,
'unit': each_input.cmd_measurement_units,
'name': each_input.cmd_measurement
}
})
# Add ADC measurements/units to measurements dictionary
elif (each_input.adc_measure and each_input.adc_measure_units
and each_input.adc_measure not in measurement_units):
return_measurements.update({
each_input.adc_measure: {
'meas': each_input.adc_measure,
'unit': each_input.adc_measure_units,
'name': each_input.adc_measure
}
})
# Add converted measurements/units to measurements dictionary
elif each_input.unique_id in use_unit:
for each_measure in use_unit[each_input.unique_id]:
if (use_unit[each_input.unique_id][each_measure] is not None
and use_unit[each_input.unique_id][each_measure]
in UNITS):
return_measurements.update({
use_unit[each_input.unique_id][each_measure]: {
'meas':
use_unit[each_input.unique_id][each_measure],
'unit':
UNITS[use_unit[each_input.unique_id]
[each_measure]]['unit'],
'name':
UNITS[use_unit[each_input.unique_id][each_measure]]
['name']
}
})
for each_math in maths:
# Add Math measurements/units to measurements dictionary
if (each_math.measure and each_math.measure_units
and each_math.measure not in measurement_units):
return_measurements.update({
each_math.measure: {
'meas': each_math.measure,
'unit': each_math.measure_units,
'name': each_math.measure
}
})
return return_measurements
def page_dashboard(dashboard_id):
""" Generate custom dashboard with various data """
# Retrieve tables from SQL database
camera = Camera.query.all()
conditional = Conditional.query.all()
function = CustomController.query.all()
widget = Widget.query.all()
this_dashboard = Dashboard.query.filter(
Dashboard.unique_id == dashboard_id).first()
input_dev = Input.query.all()
device_measurements = DeviceMeasurements.query.all()
math = Math.query.all()
method = Method.query.all()
misc = Misc.query.first()
output = Output.query.all()
output_channel = OutputChannel.query.all()
pid = PID.query.all()
tags = NoteTags.query.all()
# Create form objects
form_base = forms_dashboard.DashboardBase()
form_dashboard = forms_dashboard.DashboardConfig()
if request.method == 'POST':
unmet_dependencies = None
if not utils_general.user_has_permission('edit_controllers'):
return redirect(url_for('routes_general.home'))
# Dashboard
if form_dashboard.dash_modify.data:
utils_dashboard.dashboard_mod(form_dashboard)
elif form_dashboard.dash_duplicate.data:
utils_dashboard.dashboard_copy(form_dashboard)
elif form_dashboard.lock.data:
utils_dashboard.dashboard_lock(form_dashboard.dashboard_id.data,
True)
elif form_dashboard.unlock.data:
utils_dashboard.dashboard_lock(form_dashboard.dashboard_id.data,
False)
elif form_dashboard.dash_delete.data:
utils_dashboard.dashboard_del(form_dashboard)
return redirect(url_for('routes_dashboard.page_dashboard_default'))
# Widget
elif form_base.create.data:
unmet_dependencies = utils_dashboard.widget_add(
form_base, request.form)
elif form_base.modify.data:
utils_dashboard.widget_mod(form_base, request.form)
elif form_base.delete.data:
utils_dashboard.widget_del(form_base)
if unmet_dependencies:
return redirect(
url_for('routes_admin.admin_dependencies',
device=form_base.graph_type.data))
return redirect(
url_for('routes_dashboard.page_dashboard',
dashboard_id=dashboard_id))
# Generate all measurement and units used
dict_measurements = add_custom_measurements(Measurement.query.all())
dict_units = add_custom_units(Unit.query.all())
# Generate dictionary of each measurement ID with the correct measurement/unit used with it
dict_measure_measurements = {}
dict_measure_units = {}
for each_measurement in device_measurements:
# If the measurement is a PID setpoint, set unit to PID measurement.
measurement = None
unit = None
if each_measurement.measurement_type == 'setpoint':
setpoint_pid = PID.query.filter(
PID.unique_id == each_measurement.device_id).first()
if setpoint_pid and ',' in setpoint_pid.measurement:
pid_measurement = setpoint_pid.measurement.split(',')[1]
setpoint_measurement = DeviceMeasurements.query.filter(
DeviceMeasurements.unique_id == pid_measurement).first()
if setpoint_measurement:
conversion = Conversion.query.filter(
Conversion.unique_id ==
setpoint_measurement.conversion_id).first()
_, unit, measurement = return_measurement_info(
setpoint_measurement, conversion)
else:
conversion = Conversion.query.filter(
Conversion.unique_id ==
each_measurement.conversion_id).first()
_, unit, measurement = return_measurement_info(
each_measurement, conversion)
if unit:
dict_measure_measurements[each_measurement.unique_id] = measurement
dict_measure_units[each_measurement.unique_id] = unit
dict_outputs = parse_output_information()
dict_widgets = parse_widget_information()
custom_options_values_widgets = parse_custom_option_values_json(
widget, dict_controller=dict_widgets)
custom_options_values_output_channels = parse_custom_option_values_output_channels_json(
output_channel,
dict_controller=dict_outputs,
key_name='custom_channel_options')
widget_types_on_dashboard = []
custom_widget_variables = {}
widgets_dash = Widget.query.filter(
Widget.dashboard_id == dashboard_id).all()
for each_widget in widgets_dash:
# Make list of widget types on this particular dashboard
if each_widget.graph_type not in widget_types_on_dashboard:
widget_types_on_dashboard.append(each_widget.graph_type)
# Generate dictionary of returned values from widget modules on this particular dashboard
if 'generate_page_variables' in dict_widgets[each_widget.graph_type]:
custom_widget_variables[each_widget.unique_id] = dict_widgets[
each_widget.graph_type]['generate_page_variables'](
each_widget.unique_id,
custom_options_values_widgets[each_widget.unique_id])
# generate lists of html files to include in dashboard template
list_html_files_body = {}
list_html_files_title_bar = {}
list_html_files_head = {}
list_html_files_configure_options = {}
list_html_files_js = {}
list_html_files_js_ready = {}
list_html_files_js_ready_end = {}
for each_widget_type in widget_types_on_dashboard:
file_html_head = "widget_template_{}_head.html".format(
each_widget_type)
path_html_head = os.path.join(PATH_HTML_USER, file_html_head)
if os.path.exists(path_html_head):
list_html_files_head[each_widget_type] = file_html_head
file_html_title_bar = "widget_template_{}_title_bar.html".format(
each_widget_type)
path_html_title_bar = os.path.join(PATH_HTML_USER, file_html_title_bar)
if os.path.exists(path_html_title_bar):
list_html_files_title_bar[each_widget_type] = file_html_title_bar
file_html_body = "widget_template_{}_body.html".format(
each_widget_type)
path_html_body = os.path.join(PATH_HTML_USER, file_html_body)
if os.path.exists(path_html_body):
list_html_files_body[each_widget_type] = file_html_body
file_html_configure_options = "widget_template_{}_configure_options.html".format(
each_widget_type)
path_html_configure_options = os.path.join(
PATH_HTML_USER, file_html_configure_options)
if os.path.exists(path_html_configure_options):
list_html_files_configure_options[
each_widget_type] = file_html_configure_options
file_html_js = "widget_template_{}_js.html".format(each_widget_type)
path_html_js = os.path.join(PATH_HTML_USER, file_html_js)
if os.path.exists(path_html_js):
list_html_files_js[each_widget_type] = file_html_js
file_html_js_ready = "widget_template_{}_js_ready.html".format(
each_widget_type)
path_html_js_ready = os.path.join(PATH_HTML_USER, file_html_js_ready)
if os.path.exists(path_html_js_ready):
list_html_files_js_ready[each_widget_type] = file_html_js_ready
file_html_js_ready_end = "widget_template_{}_js_ready_end.html".format(
each_widget_type)
path_html_js_ready_end = os.path.join(PATH_HTML_USER,
file_html_js_ready_end)
if os.path.exists(path_html_js_ready_end):
list_html_files_js_ready_end[
each_widget_type] = file_html_js_ready_end
# Retrieve all choices to populate form drop-down menu
choices_camera = utils_general.choices_id_name(camera)
choices_function = utils_general.choices_functions(function, dict_units,
dict_measurements)
choices_input = utils_general.choices_inputs(input_dev, dict_units,
dict_measurements)
choices_math = utils_general.choices_maths(math, dict_units,
dict_measurements)
choices_method = utils_general.choices_methods(method)
choices_output = utils_general.choices_outputs(output, dict_units,
dict_measurements)
choices_output_channels_measurements = utils_general.choices_outputs_channels_measurements(
output, OutputChannel, dict_outputs, dict_units, dict_measurements)
choices_output_pwm = utils_general.choices_outputs_pwm(
output, dict_units, dict_measurements, dict_outputs)
choices_pid = utils_general.choices_pids(pid, dict_units,
dict_measurements)
choices_pid_devices = utils_general.choices_pids_devices(pid)
choices_tag = utils_general.choices_tags(tags)
device_measurements_dict = {}
for meas in device_measurements:
device_measurements_dict[meas.unique_id] = meas
# Get what each measurement uses for a unit
use_unit = utils_general.use_unit_generate(device_measurements, input_dev,
output, math, function)
return render_template(
'pages/dashboard.html',
conditional=conditional,
custom_options_values_output_channels=
custom_options_values_output_channels,
custom_options_values_widgets=custom_options_values_widgets,
custom_widget_variables=custom_widget_variables,
table_conversion=Conversion,
table_function=CustomController,
table_widget=Widget,
table_input=Input,
table_math=Math,
table_output=Output,
table_pid=PID,
table_device_measurements=DeviceMeasurements,
choices_camera=choices_camera,
choices_function=choices_function,
choices_input=choices_input,
choices_math=choices_math,
choices_method=choices_method,
choices_output=choices_output,
choices_output_channels_measurements=
choices_output_channels_measurements,
choices_output_pwm=choices_output_pwm,
choices_pid=choices_pid,
choices_pid_devices=choices_pid_devices,
choices_tag=choices_tag,
dashboard_id=dashboard_id,
device_measurements_dict=device_measurements_dict,
dict_measure_measurements=dict_measure_measurements,
dict_measure_units=dict_measure_units,
dict_measurements=dict_measurements,
dict_units=dict_units,
dict_widgets=dict_widgets,
list_html_files_head=list_html_files_head,
list_html_files_title_bar=list_html_files_title_bar,
list_html_files_body=list_html_files_body,
list_html_files_configure_options=list_html_files_configure_options,
list_html_files_js=list_html_files_js,
list_html_files_js_ready=list_html_files_js_ready,
list_html_files_js_ready_end=list_html_files_js_ready_end,
camera=camera,
function=function,
math=math,
misc=misc,
pid=pid,
output=output,
output_types=output_types(),
input=input_dev,
tags=tags,
this_dashboard=this_dashboard,
use_unit=use_unit,
form_base=form_base,
form_dashboard=form_dashboard,
widget=widget)
def setup_lcd_line(self, display_id, line, device_id, measurement):
self.lcd_line[display_id][line]['setup'] = False
self.lcd_line[display_id][line]['id'] = device_id
self.lcd_line[display_id][line]['name'] = None
self.lcd_line[display_id][line]['unit'] = None
self.lcd_line[display_id][line]['measure'] = measurement
if 'time' in measurement:
self.lcd_line[display_id][line]['measure'] = 'time'
if not device_id:
return
# Determine the unit of the PID setpoint
if measurement == 'setpoint':
pid = db_retrieve_table_daemon(PID, unique_id=device_id)
if pid:
if pid.measurement.split(',')[1] in self.list_inputs:
# Determine if the PID input is a math or input controller
pid_math = db_retrieve_table_daemon(
Math, unique_id=pid.measurement.split(',')[0])
pid_input = db_retrieve_table_daemon(
Input, unique_id=pid.measurement.split(',')[0])
list_measure_units = []
setpoint_unit = ''
if pid_math:
list_measure_units = pid_math.measure_units.split(';')
if pid_input:
list_measure_units = pid_input.convert_to_unit.split(
';')
for each_measure_unit in list_measure_units:
if (len(each_measure_unit.split(',')) == 2
and each_measure_unit.split(',')[0]
== pid.measurement.split(',')[1]):
setpoint_unit = self.dict_units[
each_measure_unit.split(',')[1]]['unit']
self.lcd_line[display_id][line]['unit'] = setpoint_unit
else:
self.lcd_line[display_id][line]['unit'] = ''
elif measurement in self.list_inputs:
# Get what each measurement uses for a unit
input_dev = db_retrieve_table_daemon(Input)
output = db_retrieve_table_daemon(Output)
math = db_retrieve_table_daemon(Math)
use_unit = use_unit_generate(input_dev, output, math)
if (device_id in use_unit and measurement in use_unit[device_id]
and use_unit[device_id][measurement] is not None):
self.lcd_line[display_id][line]['unit'] = UNITS[
use_unit[device_id][measurement]]['unit']
elif 'unit' in self.list_inputs[measurement]:
self.lcd_line[display_id][line]['unit'] = self.list_inputs[
measurement]['unit']
else:
self.lcd_line[display_id][line]['unit'] = ''
else:
self.lcd_line[display_id][line]['unit'] = ''
# Determine the name
controllers = [Output, PID, Input, Math]
for each_controller in controllers:
controller_found = db_retrieve_table_daemon(each_controller,
unique_id=device_id)
if controller_found:
self.lcd_line[display_id][line]['name'] = controller_found.name
if (self.lcd_line[display_id][line]['measure'] in ['IP', 'time']
or None not in [
self.lcd_line[display_id][line]['name'],
self.lcd_line[display_id][line]['unit']
]):
self.lcd_line[display_id][line]['setup'] = True
