mirror of
https://github.com/migatu/vtt_work.git
synced 2026-07-14 13:34:42 +00:00
1805 lines
93 KiB
Python
1805 lines
93 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
Control Board Monitor — v1.8
|
||
|
||
What’s new:
|
||
- POSTs are now **exactly** like the sample app:
|
||
POST http://<host>:<port>/?variable=<NAME>&value=<ARG> (method=POST, no body)
|
||
(All previous POST modes removed.)
|
||
- Select Variables dialog: typing in the filter **does not clear** previously ticked checkboxes.
|
||
- Mouse wheel scrolling enabled (selector canvas, main variables tree, actions tree).
|
||
"""
|
||
|
||
import json
|
||
import math
|
||
import queue
|
||
import re
|
||
import threading
|
||
from collections import deque
|
||
import time
|
||
import urllib.parse
|
||
import urllib.request
|
||
from dataclasses import dataclass, field
|
||
from datetime import datetime
|
||
from typing import Dict, List, Optional, Tuple, Deque
|
||
|
||
try:
|
||
import tkinter as tk
|
||
from tkinter import ttk, messagebox
|
||
except Exception:
|
||
raise SystemExit("Tkinter is required to run this app.")
|
||
|
||
# =====================
|
||
# Global configuration
|
||
# =====================
|
||
AVERAGE_WINDOW_N: int = 60 # default for moving average window (cycles)
|
||
SERVER_HOST: str = "localhost"
|
||
SERVER_PORT: int = 8785
|
||
REFRESH_INTERVAL_S: int = 1
|
||
REQUEST_TIMEOUT_S: float = 5.0
|
||
USER_AGENT: str = "ControlBoardMonitor/1.9 (+tkinter)"
|
||
|
||
# Fallback defaults (extracted from your HTML)
|
||
DEFAULT_VARS: List[str] = ['ALARMS_ACTIVE', 'AMBIENT_TEMPERATURE', 'CHEM_BORON_DOSAGE_ACTUAL', 'CHEM_BORON_DOSAGE_ORDERED', 'CHEM_BORON_FILTER_ACTUAL', 'CHEM_BORON_FILTER_ORDERED', 'CHEM_BORON_PPM', 'CHEM_TRUCK_CONNECTED', 'CHEM_TRUCK_IN_ZONE', 'CHEMICAL_CLEANING_PUMP_DRY_STATUS', 'CHEMICAL_CLEANING_PUMP_OVERLOAD_STATUS', 'CHEMICAL_CLEANING_PUMP_STATUS', 'CHEMICAL_DOSING_PUMP_DRY_STATUS', 'CHEMICAL_DOSING_PUMP_OVERLOAD_STATUS', 'CHEMICAL_DOSING_PUMP_STATUS', 'CHEMICAL_FILTER_PUMP_DRY_STATUS', 'CHEMICAL_FILTER_PUMP_OVERLOAD_STATUS', 'CHEMICAL_FILTER_PUMP_STATUS', 'CONDENSER_CIRCULATION_PUMP_ACTIVE', 'CONDENSER_CIRCULATION_PUMP_ORDERED_SPEED', 'CONDENSER_CIRCULATION_PUMP_OVERLOAD_STATUS', 'CONDENSER_CIRCULATION_PUMP_SPEED', 'CONDENSER_CIRCULATION_PUMP_SWITCH', 'CONDENSER_CONDENSATE_FLOW_RATE', 'CONDENSER_COOLANT_EVAPORATED', 'CONDENSER_EXTRACTION_FLOW_RATE', 'CONDENSER_PRESSURE', 'CONDENSER_TEMPERATURE', 'CONDENSER_VACUUM', 'CONDENSER_VACUUM_PUMP_ACTIVE', 'CONDENSER_VACUUM_PUMP_MODE', 'CONDENSER_VACUUM_PUMP_POWER', 'CONDENSER_VACUUM_RELIEF_VALVE_OPENING', 'CONDENSER_VAPOR_VOLUME', 'CONDENSER_VOLUME', 'COOLANT_CORE_CIRCULATION_PUMP_0_CAPACITY', 'COOLANT_CORE_CIRCULATION_PUMP_0_DRY_STATUS', 'COOLANT_CORE_CIRCULATION_PUMP_0_ORDERED_SPEED', 'COOLANT_CORE_CIRCULATION_PUMP_0_OVERLOAD_STATUS', 'COOLANT_CORE_CIRCULATION_PUMP_0_SPEED', 'COOLANT_CORE_CIRCULATION_PUMP_0_STATUS', 'COOLANT_CORE_CIRCULATION_PUMP_1_CAPACITY', 'COOLANT_CORE_CIRCULATION_PUMP_1_DRY_STATUS', 'COOLANT_CORE_CIRCULATION_PUMP_1_ORDERED_SPEED', 'COOLANT_CORE_CIRCULATION_PUMP_1_OVERLOAD_STATUS', 'COOLANT_CORE_CIRCULATION_PUMP_1_SPEED', 'COOLANT_CORE_CIRCULATION_PUMP_1_STATUS', 'COOLANT_CORE_CIRCULATION_PUMP_2_CAPACITY', 'COOLANT_CORE_CIRCULATION_PUMP_2_DRY_STATUS', 'COOLANT_CORE_CIRCULATION_PUMP_2_ORDERED_SPEED', 'COOLANT_CORE_CIRCULATION_PUMP_2_OVERLOAD_STATUS', 'COOLANT_CORE_CIRCULATION_PUMP_2_SPEED', 'COOLANT_CORE_CIRCULATION_PUMP_2_STATUS', 'COOLANT_CORE_FLOW_IN', 'COOLANT_CORE_FLOW_ORDERED_SPEED', 'COOLANT_CORE_FLOW_OUT', 'COOLANT_CORE_FLOW_REACHED_SPEED', 'COOLANT_CORE_FLOW_SPEED', 'COOLANT_CORE_MAX_PRESSURE', 'COOLANT_CORE_PRESSURE', 'COOLANT_CORE_PRIMARY_LOOP_LEVEL', 'COOLANT_CORE_QUANTITY_CIRCULATION_PUMPS_PRESENT', 'COOLANT_CORE_QUANTITY_FREIGHT_PUMPS_PRESENT', 'COOLANT_CORE_QUANTITY_IN_VESSEL', 'COOLANT_CORE_STATE', 'COOLANT_CORE_VESSEL_TEMPERATURE', 'COOLANT_SEC_0_LIQUID_VOLUME', 'COOLANT_SEC_0_PRESSURE', 'COOLANT_SEC_0_TEMPERATURE', 'COOLANT_SEC_0_VOLUME', 'COOLANT_SEC_1_LIQUID_VOLUME', 'COOLANT_SEC_1_PRESSURE', 'COOLANT_SEC_1_TEMPERATURE', 'COOLANT_SEC_1_VOLUME', 'COOLANT_SEC_2_LIQUID_VOLUME', 'COOLANT_SEC_2_PRESSURE', 'COOLANT_SEC_2_TEMPERATURE', 'COOLANT_SEC_2_VOLUME', 'COOLANT_SEC_CIRCULATION_PUMP_0_CAPACITY', 'COOLANT_SEC_CIRCULATION_PUMP_0_DRY_STATUS', 'COOLANT_SEC_CIRCULATION_PUMP_0_ORDERED_SPEED', 'COOLANT_SEC_CIRCULATION_PUMP_0_OVERLOAD_STATUS', 'COOLANT_SEC_CIRCULATION_PUMP_0_SPEED', 'COOLANT_SEC_CIRCULATION_PUMP_0_STATUS', 'COOLANT_SEC_CIRCULATION_PUMP_1_CAPACITY', 'COOLANT_SEC_CIRCULATION_PUMP_1_DRY_STATUS', 'COOLANT_SEC_CIRCULATION_PUMP_1_ORDERED_SPEED', 'COOLANT_SEC_CIRCULATION_PUMP_1_OVERLOAD_STATUS', 'COOLANT_SEC_CIRCULATION_PUMP_1_SPEED', 'COOLANT_SEC_CIRCULATION_PUMP_1_STATUS', 'COOLANT_SEC_CIRCULATION_PUMP_2_CAPACITY', 'COOLANT_SEC_CIRCULATION_PUMP_2_DRY_STATUS', 'COOLANT_SEC_CIRCULATION_PUMP_2_ORDERED_SPEED', 'COOLANT_SEC_CIRCULATION_PUMP_2_OVERLOAD_STATUS', 'COOLANT_SEC_CIRCULATION_PUMP_2_SPEED', 'COOLANT_SEC_CIRCULATION_PUMP_2_STATUS', 'CORE_BAY_1_HATCH_OPEN', 'CORE_BAY_1_STATE', 'CORE_BAY_2_HATCH_OPEN', 'CORE_BAY_2_STATE', 'CORE_BAY_3_HATCH_OPEN', 'CORE_BAY_3_STATE', 'CORE_BAY_4_HATCH_OPEN', 'CORE_BAY_4_STATE', 'CORE_BAY_5_HATCH_OPEN', 'CORE_BAY_5_STATE', 'CORE_BAY_6_HATCH_OPEN', 'CORE_BAY_6_STATE', 'CORE_BAY_7_HATCH_OPEN', 'CORE_BAY_7_STATE', 'CORE_BAY_8_HATCH_OPEN', 'CORE_BAY_8_STATE', 'CORE_BAY_9_HATCH_OPEN', 'CORE_BAY_9_STATE', 'CORE_CRITICAL_MASS_REACHED', 'CORE_CRITICAL_MASS_REACHED_COUNTER', 'CORE_EXTERNAL_COOLANT_RESERVOIR_VOLUME', 'CORE_FACTOR', 'CORE_FACTOR_CHANGE', 'CORE_FUEL_1_FISSIONABLE', 'CORE_FUEL_1_POWER_FACTOR', 'CORE_FUEL_1_TEMPERATURE', 'CORE_FUEL_2_FISSIONABLE', 'CORE_FUEL_2_POWER_FACTOR', 'CORE_FUEL_2_TEMPERATURE', 'CORE_FUEL_3_FISSIONABLE', 'CORE_FUEL_3_POWER_FACTOR', 'CORE_FUEL_3_TEMPERATURE', 'CORE_FUEL_4_FISSIONABLE', 'CORE_FUEL_4_POWER_FACTOR', 'CORE_FUEL_4_TEMPERATURE', 'CORE_FUEL_5_FISSIONABLE', 'CORE_FUEL_5_POWER_FACTOR', 'CORE_FUEL_5_TEMPERATURE', 'CORE_FUEL_6_FISSIONABLE', 'CORE_FUEL_6_POWER_FACTOR', 'CORE_FUEL_6_TEMPERATURE', 'CORE_FUEL_7_FISSIONABLE', 'CORE_FUEL_7_POWER_FACTOR', 'CORE_FUEL_7_TEMPERATURE', 'CORE_FUEL_8_FISSIONABLE', 'CORE_FUEL_8_POWER_FACTOR', 'CORE_FUEL_8_TEMPERATURE', 'CORE_FUEL_9_FISSIONABLE', 'CORE_FUEL_9_POWER_FACTOR', 'CORE_FUEL_9_TEMPERATURE', 'CORE_FUEL_AVG_FISSIONABLE', 'CORE_FUEL_AVG_POWER_FACTOR', 'CORE_FUEL_AVG_TEMPERATURE', 'CORE_HIGH_STEAM_PRESENT', 'CORE_IMMINENT_FUSION', 'CORE_INTEGRITY', 'CORE_IODINE_CUMULATIVE', 'CORE_IODINE_GENERATION', 'CORE_OPERATION_MODE', 'CORE_POOL_COOLANT_TANK_VOLUME', 'CORE_POOL_PUMP', 'CORE_PRESSURE', 'CORE_PRESSURE_MAX', 'CORE_PRESSURE_OPERATIVE', 'CORE_PRIMARY_CIRCUIT_COOLING_TANK_VOLUME', 'CORE_READY_FOR_START', 'CORE_STATE', 'CORE_STATE_CRITICALITY', 'CORE_STEAM_PRESENT', 'CORE_TEMP', 'CORE_TEMP_MAX', 'CORE_TEMP_MIN', 'CORE_TEMP_OPERATIVE', 'CORE_TEMP_RESIDUAL', 'CORE_WEAR', 'CORE_XENON_CUMULATIVE', 'CORE_XENON_GENERATION', 'EMERGENCY_BATTERIES_MODE', 'EMERGENCY_BATTERIES_POWER_OUTPUT_KW', 'EMERGENCY_GENERATOR_1_FUEL', 'EMERGENCY_GENERATOR_1_MAINTENANCE_NEEDED', 'EMERGENCY_GENERATOR_1_MODE', 'EMERGENCY_GENERATOR_1_PRESSURIZER', 'EMERGENCY_GENERATOR_1_STATUS', 'EMERGENCY_GENERATOR_2_FUEL', 'EMERGENCY_GENERATOR_2_MAINTENANCE_NEEDED', 'EMERGENCY_GENERATOR_2_MODE', 'EMERGENCY_GENERATOR_2_PRESSURIZER', 'EMERGENCY_GENERATOR_2_STATUS', 'EMERGENCY_GENERATOR_POWER_OUTPUT_KW', 'FREIGHT_PUMP_CONDENSER_ACTIVE', 'FREIGHT_PUMP_CONDENSER_SWITCH', 'FREIGHT_PUMP_EXTERNAL_ACTIVE', 'FREIGHT_PUMP_EXTERNAL_SWITCH', 'FREIGHT_PUMP_FEEDWATER_ACTIVE', 'FREIGHT_PUMP_FEEDWATER_SWITCH', 'FREIGHT_PUMP_INTERNAL_ACTIVE', 'FREIGHT_PUMP_INTERNAL_SWITCH', 'FUN_IS_ENABLED', 'GAME_DIFFICULTY', 'GAME_SIM_SPEED', 'GAME_VERSION', 'GENERATOR_0_A', 'GENERATOR_0_BREAKER', 'GENERATOR_0_HERTZ', 'GENERATOR_0_KW', 'GENERATOR_0_V', 'GENERATOR_1_A', 'GENERATOR_1_BREAKER', 'GENERATOR_1_HERTZ', 'GENERATOR_1_KW', 'GENERATOR_1_V', 'GENERATOR_2_A', 'GENERATOR_2_BREAKER', 'GENERATOR_2_HERTZ', 'GENERATOR_2_KW', 'GENERATOR_2_V', 'INSTALLED_LOOPS_JSON', 'INVENTORY_HTML', 'MAINTENANCE_REPORT_HTML', 'MSCV_0_OPENING_ACTUAL', 'MSCV_1_OPENING_ACTUAL', 'MSCV_2_OPENING_ACTUAL', 'POWER_DEMAND_MW', 'POWER_FROM_EXTERNAL_KW', 'POWER_FROM_TURBINE_KW', 'POWER_MAX_THEORETICAL_FINAL_PLANT_OUTPUT_MW', 'POWER_MAX_THEORETICAL_PLANT_OUTPUT_MW', 'RES_ABSORPTION_CAPACITY_MW', 'RES_DIVERT_SURPLUS_FROM_MW', 'RES_EFFECTIVELY_DERIVED_ENERGY_MW', 'RESISTOR_BANK_01_SWITCH', 'RESISTOR_BANK_02_SWITCH', 'RESISTOR_BANK_03_SWITCH', 'RESISTOR_BANK_04_SWITCH', 'RESISTOR_BANKS_JSON', 'RESISTOR_BANKS_MAIN_SWITCH', 'ROD_BANK_POS_0_ACTUAL', 'ROD_BANK_POS_0_ORDERED', 'ROD_BANK_POS_1_ACTUAL', 'ROD_BANK_POS_1_ORDERED', 'ROD_BANK_POS_2_ACTUAL', 'ROD_BANK_POS_2_ORDERED', 'ROD_BANK_POS_3_ACTUAL', 'ROD_BANK_POS_3_ORDERED', 'ROD_BANK_POS_4_ACTUAL', 'ROD_BANK_POS_4_ORDERED', 'ROD_BANK_POS_5_ACTUAL', 'ROD_BANK_POS_5_ORDERED', 'ROD_BANK_POS_6_ACTUAL', 'ROD_BANK_POS_6_ORDERED', 'ROD_BANK_POS_7_ACTUAL', 'ROD_BANK_POS_7_ORDERED', 'ROD_BANK_POS_8_ACTUAL', 'ROD_BANK_POS_8_ORDERED', 'RODS_ALIGNED', 'RODS_DEFORMED', 'RODS_MAX_TEMPERATURE', 'RODS_MOVEMENT_SPEED', 'RODS_MOVEMENT_SPEED_DECREASED_HIGH_TEMPERATURE', 'RODS_POS_ACTUAL', 'RODS_POS_ORDERED', 'RODS_POS_REACHED', 'RODS_QUANTITY', 'RODS_STATUS', 'RODS_TEMPERATURE', 'STEAM_EJECTOR_CONDENSER_RETURN_VALVE_ACTUAL', 'STEAM_EJECTOR_CONDENSER_RETURN_VALVE_ORDERED', 'STEAM_EJECTOR_MOTIVE', 'STEAM_EJECTOR_OPERATIONAL_MOTIVE_VALVE_ACTUAL', 'STEAM_EJECTOR_OPERATIONAL_MOTIVE_VALVE_ORDERED', 'STEAM_EJECTOR_STARTUP_MOTIVE_VALVE_ACTUAL', 'STEAM_EJECTOR_STARTUP_MOTIVE_VALVE_ORDERED', 'STEAM_GEN_0_BOILING_POINT', 'STEAM_GEN_0_EVAPORATED', 'STEAM_GEN_0_INLET', 'STEAM_GEN_0_OUTLET', 'STEAM_GEN_0_RETURN_FLOW_PLUS_CONDENSED', 'STEAM_GEN_0_STATUS', 'STEAM_GEN_0_VENT_SWITCH', 'STEAM_GEN_1_BOILING_POINT', 'STEAM_GEN_1_EVAPORATED', 'STEAM_GEN_1_INLET', 'STEAM_GEN_1_OUTLET', 'STEAM_GEN_1_RETURN_FLOW_PLUS_CONDENSED', 'STEAM_GEN_1_STATUS', 'STEAM_GEN_1_VENT_SWITCH', 'STEAM_GEN_2_BOILING_POINT', 'STEAM_GEN_2_EVAPORATED', 'STEAM_GEN_2_INLET', 'STEAM_GEN_2_OUTLET', 'STEAM_GEN_2_RETURN_FLOW_PLUS_CONDENSED', 'STEAM_GEN_2_STATUS', 'STEAM_GEN_2_VENT_SWITCH', 'STEAM_TURBINE_0_BYPASS_ACTUAL', 'STEAM_TURBINE_0_INSTALLED', 'STEAM_TURBINE_0_PRESSURE', 'STEAM_TURBINE_0_RPM', 'STEAM_TURBINE_0_TEMPERATURE', 'STEAM_TURBINE_0_TORQUE', 'STEAM_TURBINE_1_BYPASS_ACTUAL', 'STEAM_TURBINE_1_INSTALLED', 'STEAM_TURBINE_1_PRESSURE', 'STEAM_TURBINE_1_RPM', 'STEAM_TURBINE_1_TEMPERATURE', 'STEAM_TURBINE_1_TORQUE', 'STEAM_TURBINE_2_BYPASS_ACTUAL', 'STEAM_TURBINE_2_INSTALLED', 'STEAM_TURBINE_2_PRESSURE', 'STEAM_TURBINE_2_RPM', 'STEAM_TURBINE_2_TEMPERATURE', 'STEAM_TURBINE_2_TORQUE', 'TIME', 'TIME_DAY', 'TIME_STAMP', 'VACUUM_RETENTION_TANK_PRESSURE', 'VACUUM_RETENTION_TANK_VOLUME', 'VALVE_M01_OPEN', 'VALVE_M02_OPEN', 'VALVE_M03_OPEN', 'VALVE_PANEL_JSON', 'WEATHER_FORECAST_JSON', 'WEBSERVER_BATCH_GET', 'WEBSERVER_LIST_VARIABLES', 'WEBSERVER_LIST_VARIABLES_JSON', 'WEBSERVER_VIEW_VARIABLES']
|
||
DEFAULT_FUNCTIONS: List[str] = ['CHEM_BORON_DOSAGE_ORDERED_RATE', 'CHEM_BORON_FILTER_ORDERED_SPEED', 'CONDENSER_CIRCULATION_PUMP_ORDERED_SPEED', 'CONDENSER_CIRCULATION_PUMP_SWITCH', 'CONDENSER_VACUUM_PUMP_MODE', 'CONDENSER_VACUUM_PUMP_START_STOP', 'COOLANT_CORE_CIRCULATION_PUMP_0_ORDERED_SPEED', 'COOLANT_CORE_CIRCULATION_PUMP_1_ORDERED_SPEED', 'COOLANT_CORE_CIRCULATION_PUMP_2_ORDERED_SPEED', 'COOLANT_SEC_CIRCULATION_PUMP_0_ORDERED_SPEED', 'COOLANT_SEC_CIRCULATION_PUMP_1_ORDERED_SPEED', 'COOLANT_SEC_CIRCULATION_PUMP_2_ORDERED_SPEED', 'CORE_BAY_1_FUEL_LOADING', 'CORE_BAY_1_HATCH', 'CORE_BAY_2_FUEL_LOADING', 'CORE_BAY_2_HATCH', 'CORE_BAY_3_FUEL_LOADING', 'CORE_BAY_3_HATCH', 'CORE_BAY_4_FUEL_LOADING', 'CORE_BAY_4_HATCH', 'CORE_BAY_5_FUEL_LOADING', 'CORE_BAY_5_HATCH', 'CORE_BAY_6_FUEL_LOADING', 'CORE_BAY_6_HATCH', 'CORE_BAY_7_FUEL_LOADING', 'CORE_BAY_7_HATCH', 'CORE_BAY_8_FUEL_LOADING', 'CORE_BAY_8_HATCH', 'CORE_BAY_9_FUEL_LOADING', 'CORE_BAY_9_HATCH', 'CORE_EMERGENCY_STOP', 'CORE_END_EMERGENCY_STOP', 'CORE_OPERATION_MODE', 'CORE_POOL_PUMP', 'CORE_SCRAM_BUTTON', 'EMERGENCY_BATTERIES_MODE', 'EMERGENCY_GENERATOR_1_MODE', 'EMERGENCY_GENERATOR_1_START_STOP', 'EMERGENCY_GENERATOR_2_MODE', 'EMERGENCY_GENERATOR_2_START_STOP', 'FREIGHT_PUMP_CONDENSER_SWITCH', 'FREIGHT_PUMP_EXTERNAL_SWITCH', 'FREIGHT_PUMP_FEEDWATER_SWITCH', 'FREIGHT_PUMP_INTERNAL_SWITCH', 'FUN_AO_SABOTAGE_ONCE', 'FUN_AO_SABOTAGE_TIME', 'FUN_BANK_ROBBERY', 'FUN_BREAKER_TRIP', 'FUN_DECREASE_INTEGRITY', 'FUN_FIRE_DRILL', 'FUN_IODINE_SPILL', 'FUN_OIL_SPILL', 'FUN_PUMP_JAM', 'FUN_REQUEST_ENABLE', 'FUN_SHOW_MESSAGE', 'FUN_TOGGLE_RANDOM_SWITCH', 'FUN_TRIGGER_AUDIT', 'FUN_WEATHER_CONTROL', 'FUN_XENON_SPILL', 'MSCV_0_OPENING_ORDERED', 'MSCV_1_OPENING_ORDERED', 'MSCV_2_OPENING_ORDERED', 'RESET_AO', 'RESISTOR_BANK_01_SWITCH', 'RESISTOR_BANK_02_SWITCH', 'RESISTOR_BANK_03_SWITCH', 'RESISTOR_BANK_04_SWITCH', 'RESISTOR_BANKS_MAIN_SWITCH', 'ROD_BANK_POS_0_ORDERED', 'ROD_BANK_POS_1_ORDERED', 'ROD_BANK_POS_2_ORDERED', 'ROD_BANK_POS_3_ORDERED', 'ROD_BANK_POS_4_ORDERED', 'ROD_BANK_POS_5_ORDERED', 'ROD_BANK_POS_6_ORDERED', 'ROD_BANK_POS_7_ORDERED', 'ROD_BANK_POS_8_ORDERED', 'RODS_ALL_POS_ORDERED', 'STEAM_EJECTOR_CONDENSER_RETURN_VALVE', 'STEAM_EJECTOR_OPERATIONAL_MOTIVE_VALVE', 'STEAM_EJECTOR_STARTUP_MOTIVE_VALVE', 'STEAM_GEN_0_VENT_SWITCH', 'STEAM_GEN_1_VENT_SWITCH', 'STEAM_GEN_2_VENT_SWITCH', 'STEAM_TURBINE_0_BYPASS_ORDERED', 'STEAM_TURBINE_1_BYPASS_ORDERED', 'STEAM_TURBINE_2_BYPASS_ORDERED', 'STEAM_TURBINE_TRIP', 'VALVE_CLOSE', 'VALVE_OFF', 'VALVE_OPEN']
|
||
|
||
# One global lock to serialize every HTTP call
|
||
_HTTP_LOCK = threading.Lock()
|
||
|
||
# =====================
|
||
# Helpers
|
||
# =====================
|
||
def build_base_url(host: str, port: int) -> str:
|
||
return f"http://{host}:{port}/"
|
||
|
||
def _request(req: urllib.request.Request) -> Tuple[int, str, Dict[str, str]]:
|
||
with _HTTP_LOCK:
|
||
try:
|
||
with urllib.request.urlopen(req, timeout=REQUEST_TIMEOUT_S) as resp:
|
||
status = resp.getcode()
|
||
body_bytes = resp.read()
|
||
try:
|
||
body = body_bytes.decode("utf-8", errors="replace")
|
||
except Exception:
|
||
body = body_bytes.decode("latin-1", errors="replace")
|
||
headers = {k.lower(): v for k, v in resp.getheaders()}
|
||
return status, body, headers
|
||
except urllib.error.HTTPError as e:
|
||
try:
|
||
body = e.read().decode("utf-8", errors="replace")
|
||
except Exception:
|
||
body = str(e)
|
||
return e.code, body, dict(e.headers or {})
|
||
except Exception as e:
|
||
return 0, str(e), {}
|
||
|
||
def http_get(base_url: str, params: Dict[str, str]) -> Tuple[int, str, Dict[str, str]]:
|
||
url = base_url + "?" + urllib.parse.urlencode(params)
|
||
req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Connection": "close"})
|
||
return _request(req)
|
||
|
||
def http_post_query(base_url: str, params: Dict[str, str]) -> Tuple[int, str, Dict[str, str]]:
|
||
# EXACT behavior requested: POST with query string, no body.
|
||
url = base_url + "?" + urllib.parse.urlencode(params)
|
||
req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Connection": "close"}, method="POST")
|
||
return _request(req)
|
||
|
||
def http_get_root(base_url: str) -> Tuple[int, str, Dict[str, str]]:
|
||
req = urllib.request.Request(base_url, headers={"User-Agent": USER_AGENT, "Connection": "close"})
|
||
return _request(req)
|
||
|
||
def coerce_preview(value: str, maxlen: int = 80) -> str:
|
||
v = value.strip().replace("\r", " ").replace("\n", " ")
|
||
return v if len(v) <= maxlen else (v[:maxlen - 1] + "…")
|
||
|
||
def parse_function_names_from_html_index(html_text: str) -> List[str]:
|
||
start = html_text.find("==== POST ====")
|
||
if start == -1:
|
||
return []
|
||
post_html = html_text[start:]
|
||
names = re.findall(r"<b>([A-Z0-9_]+)</b>", post_html)
|
||
seen = set(); uniq: List[str] = []
|
||
for n in names:
|
||
if n not in seen:
|
||
seen.add(n); uniq.append(n)
|
||
return uniq
|
||
|
||
def parse_variable_names_from_html_index(html_text: str) -> List[str]:
|
||
tokens: List[str] = []
|
||
for m in re.finditer(r'href\s*=\s*["\']([^"\']+)["\']', html_text, flags=re.I):
|
||
href = m.group(1)
|
||
parsed = urllib.parse.urlparse(href)
|
||
qs = urllib.parse.parse_qs(parsed.query)
|
||
for v in qs.get("variable", []) + qs.get("Variable", []):
|
||
tokens.append(v)
|
||
for m in re.finditer(r'(?:Variable|variable)\s*=\s*["\']?([A-Za-z0-9_.:-]+)', html_text, flags=re.I):
|
||
tokens.append(m.group(1))
|
||
seen = set(); uniq: List[str] = []
|
||
for v in tokens:
|
||
if v and v.upper() not in {"VARNAME", "VARIABLE", "NAME"} and v not in seen:
|
||
seen.add(v); uniq.append(v)
|
||
return uniq
|
||
|
||
# ---- Parse WEBSERVER_LIST_VARIABLES_JSON ----
|
||
def parse_weblist_names(body: str) -> Tuple[List[str], List[str]]:
|
||
"""Return (get_list, post_list). Keep discovered case for function names."""
|
||
try:
|
||
data = json.loads(body)
|
||
except Exception:
|
||
return [], []
|
||
get_names: List[str] = []
|
||
post_names: List[str] = []
|
||
|
||
if isinstance(data, dict):
|
||
for k, v in data.items():
|
||
key = str(k).strip().rstrip(":").upper()
|
||
if key in ("GET", "POST"):
|
||
names = extract_names_preserve_case(v)
|
||
if key == "GET":
|
||
get_names.extend(names)
|
||
else:
|
||
post_names.extend(names)
|
||
elif isinstance(data, list):
|
||
get_names.extend(extract_names_preserve_case(data))
|
||
|
||
def dedup(seq):
|
||
seen=set(); out=[]
|
||
for s in seq:
|
||
if s not in seen:
|
||
seen.add(s); out.append(s)
|
||
return out
|
||
return dedup(get_names), dedup(post_names)
|
||
|
||
def extract_names_preserve_case(value_obj) -> List[str]:
|
||
out: List[str] = []
|
||
def add(n):
|
||
if isinstance(n, str) and n and n not in out:
|
||
out.append(n)
|
||
if isinstance(value_obj, list):
|
||
for it in value_obj:
|
||
if isinstance(it, str):
|
||
add(it)
|
||
elif isinstance(it, dict):
|
||
for k in ("name","variable","var","id","func","function"):
|
||
if k in it and isinstance(it[k], str):
|
||
add(it[k])
|
||
for k in list(it.keys()):
|
||
if isinstance(k, str) and k.upper() == k:
|
||
add(k)
|
||
elif isinstance(value_obj, dict):
|
||
for k in value_obj.keys():
|
||
if isinstance(k, str):
|
||
add(k)
|
||
elif isinstance(value_obj, str):
|
||
for m in re.findall(r"[A-Za-z0-9_]+", value_obj):
|
||
add(m)
|
||
return out
|
||
|
||
# ---- Parse WEBSERVER_BATCH_GET ----
|
||
def parse_batch_values(body: str) -> Dict[str, str]:
|
||
try:
|
||
data = json.loads(body)
|
||
except Exception:
|
||
return {}
|
||
# Jeśli serwer owinął odpowiedź w {"values": {...}}, wyciągamy środek:
|
||
if isinstance(data, dict) and isinstance(data.get("values"), dict):
|
||
data = data["values"]
|
||
values: Dict[str, str] = {}
|
||
if isinstance(data, dict):
|
||
for k, v in data.items():
|
||
if not isinstance(k, str):
|
||
k = str(k)
|
||
try:
|
||
values[k] = v if isinstance(v, str) else json.dumps(v)
|
||
except Exception:
|
||
values[k] = str(v)
|
||
return values
|
||
def detect_batch_payload_type(body: str) -> str:
|
||
try:
|
||
data = json.loads(body)
|
||
if isinstance(data, dict) and isinstance(data.get("values"), dict):
|
||
return "enveloped(values+errors)"
|
||
if isinstance(data, dict):
|
||
return "flat"
|
||
except Exception:
|
||
pass
|
||
return "unknown"
|
||
|
||
# =====================
|
||
# Data model
|
||
# =====================
|
||
@dataclass
|
||
class Thresholds:
|
||
dead_low: Optional[float] = None
|
||
low: Optional[float] = None
|
||
high: Optional[float] = None
|
||
extreme_high: Optional[float] = None
|
||
# alarms (defaults: on for dead_low & extreme_high as requested)
|
||
alarm_dead_low: bool = True
|
||
alarm_low: bool = False
|
||
alarm_high: bool = False
|
||
alarm_extreme_high: bool = True
|
||
# function actions
|
||
action_dead_low: Optional[str] = None
|
||
value_dead_low: str = "1"
|
||
action_low: Optional[str] = None
|
||
value_low: str = "1"
|
||
action_high: Optional[str] = None
|
||
value_high: str = "1"
|
||
action_extreme_high: Optional[str] = None
|
||
value_extreme_high: str = "1"
|
||
# interval while-in-state (0 = once on enter)
|
||
action_dead_low_interval: float = 1.0
|
||
action_low_interval: float = 1.0
|
||
action_high_interval: float = 1.0
|
||
action_extreme_high_interval: float = 1.0
|
||
action_operating: Optional[str] = None
|
||
value_operating: str = "1"
|
||
action_operating_interval: float = 1.0
|
||
# expression actions
|
||
expr_dead_low: Optional[str] = None
|
||
expr_low: Optional[str] = None
|
||
expr_high: Optional[str] = None
|
||
expr_extreme_high: Optional[str] = None
|
||
# expression target function (per state)
|
||
expr_target_dead_low: Optional[str] = None
|
||
expr_target_low: Optional[str] = None
|
||
expr_target_high: Optional[str] = None
|
||
expr_target_extreme_high: Optional[str] = None
|
||
expr_operating: Optional[str] = None
|
||
expr_target_operating: Optional[str] = None
|
||
expr_operating_interval: float = 1.0
|
||
# sources for y and z
|
||
y_source: Optional[str] = None
|
||
z_source: Optional[str] = None
|
||
|
||
@dataclass
|
||
class VarInfo:
|
||
key: str # canonical lower-case key
|
||
display_name: str # original case as chosen
|
||
last_value: str = ""
|
||
last_updated: float = 0.0
|
||
last_status: int = 0
|
||
error: Optional[str] = None
|
||
thresholds: Thresholds = field(default_factory=Thresholds)
|
||
last_state: str = "UNKNOWN"
|
||
# analytics
|
||
delta_last: Optional[float] = None
|
||
history: Deque[float] = field(default_factory=lambda: deque(maxlen=3600))
|
||
history_delta: Deque[float] = field(default_factory=lambda: deque(maxlen=3600))
|
||
|
||
@dataclass
|
||
class ActionTask:
|
||
name: str
|
||
value: str
|
||
interval_s: float
|
||
enabled: bool = True
|
||
last_run: float = 0.0
|
||
next_run: float = 0.0
|
||
task_id: int = 0
|
||
expr: Optional[str] = None
|
||
x_src: Optional[str] = None
|
||
y_src: Optional[str] = None
|
||
z_src: Optional[str] = None
|
||
|
||
# =====================
|
||
# Scheduler thread
|
||
# =====================
|
||
class ActionScheduler(threading.Thread):
|
||
def __init__(self, get_base_url_cb, get_value_cb):
|
||
super().__init__(daemon=True)
|
||
self.get_base_url_cb = get_base_url_cb
|
||
self.get_value_cb = get_value_cb
|
||
self.tasks: Dict[int, ActionTask] = {}
|
||
self._lock = threading.Lock()
|
||
self._stop = threading.Event()
|
||
self._counter = 1
|
||
|
||
def add_task(self, task: ActionTask) -> int:
|
||
with self._lock:
|
||
tid = self._counter
|
||
self._counter += 1
|
||
task.task_id = tid
|
||
now = time.time()
|
||
task.next_run = now if task.interval_s == 0 else now + task.interval_s
|
||
self.tasks[tid] = task
|
||
return tid
|
||
|
||
def remove_task(self, task_id: int) -> None:
|
||
with self._lock:
|
||
self.tasks.pop(task_id, None)
|
||
|
||
def list_tasks(self) -> List[ActionTask]:
|
||
with self._lock:
|
||
return list(self.tasks.values())
|
||
|
||
def set_enabled(self, task_id: int, enabled: bool) -> None:
|
||
with self._lock:
|
||
t = self.tasks.get(task_id)
|
||
if t:
|
||
t.enabled = enabled
|
||
if enabled and t.interval_s > 0:
|
||
t.next_run = time.time() + t.interval_s
|
||
|
||
|
||
def run_task_once(self, task: "ActionTask") -> Tuple[int, str, Dict[str, str]]:
|
||
# Compute value if expression is provided
|
||
value_to_send = task.value
|
||
if getattr(task, "expr", None):
|
||
# fetch x/y/z using callback; None -> 0.0 for x
|
||
def gv(n):
|
||
try:
|
||
return self.get_value_cb(n) if n else None
|
||
except Exception:
|
||
return None
|
||
x = gv(task.x_src)
|
||
y = gv(task.y_src)
|
||
z = gv(task.z_src)
|
||
if x is None:
|
||
x = 0.0
|
||
try:
|
||
computed = eval_user_expression(task.expr, x, y, z)
|
||
value_to_send = str(computed)
|
||
except Exception as e:
|
||
# Return synthetic error without posting
|
||
return 0, f"Expression error: {e}", {}
|
||
base = self.get_base_url_cb()
|
||
params = {"variable": task.name, "value": value_to_send}
|
||
return http_post_query(base, params)
|
||
def run_once(self, name: str, value: str) -> Tuple[int, str, Dict[str, str]]:
|
||
base = self.get_base_url_cb()
|
||
params = {"variable": name, "value": value}
|
||
return http_post_query(base, params)
|
||
|
||
def run(self) -> None:
|
||
while not self._stop.is_set():
|
||
now = time.time()
|
||
to_run: List[ActionTask] = []
|
||
with self._lock:
|
||
for t in self.tasks.values():
|
||
if t.enabled and t.next_run <= now:
|
||
to_run.append(t)
|
||
for t in to_run:
|
||
try:
|
||
status, body, _ = self.run_task_once(t)
|
||
t.last_run = now
|
||
if t.interval_s > 0:
|
||
t.next_run = now + t.interval_s
|
||
else:
|
||
self.remove_task(t.task_id)
|
||
except Exception:
|
||
if t.interval_s > 0:
|
||
t.next_run = now + t.interval_s
|
||
else:
|
||
self.remove_task(t.task_id)
|
||
time.sleep(0.25)
|
||
|
||
def stop(self) -> None:
|
||
self._stop.set()
|
||
|
||
# =====================
|
||
# Poller thread (uses BATCH_GET)
|
||
# =====================
|
||
class Poller(threading.Thread):
|
||
def __init__(
|
||
self,
|
||
host: str,
|
||
port: int,
|
||
variables_keys: List[str], # canonical lower-case keys
|
||
ui_queue: queue.Queue,
|
||
refresh_interval: float,
|
||
stop_event: threading.Event,
|
||
paused_event: threading.Event,
|
||
) -> None:
|
||
super().__init__(daemon=True)
|
||
self.host = host
|
||
self.port = port
|
||
self.variables_keys = variables_keys
|
||
self.ui_queue = ui_queue
|
||
self.refresh_interval = float(max(0.1, refresh_interval))
|
||
self.stop_event = stop_event
|
||
self.paused_event = paused_event
|
||
|
||
def run(self) -> None:
|
||
base_url = build_base_url(self.host, self.port)
|
||
while not self.stop_event.is_set():
|
||
cycle_start = time.time()
|
||
self.ui_queue.put(("cycle_start", datetime.now().strftime("%H:%M:%S")))
|
||
|
||
status, body, _ = http_get(base_url, {"variable": "WEBSERVER_BATCH_GET"})
|
||
if status == 200:
|
||
fmt = detect_batch_payload_type(body)
|
||
self.ui_queue.put(("batch_fmt", fmt))
|
||
values_map = parse_batch_values(body)
|
||
if values_map:
|
||
lower_map = {k.lower(): v for k, v in values_map.items()}
|
||
# push full batch to UI for 'y' lookups
|
||
self.ui_queue.put(("batch", lower_map))
|
||
for key in list(self.variables_keys):
|
||
if key in lower_map:
|
||
self.ui_queue.put(("update", key, str(lower_map[key]), 200))
|
||
else:
|
||
self.ui_queue.put(("error", key, 206, "Not in BATCH_GET payload"))
|
||
else:
|
||
for key in list(self.variables_keys):
|
||
st, b, _h = http_get(base_url, {"variable": key})
|
||
if st == 200:
|
||
self.ui_queue.put(("update", key, b, st))
|
||
else:
|
||
self.ui_queue.put(("error", key, st, coerce_preview(b, 200)))
|
||
else:
|
||
for key in list(self.variables_keys):
|
||
st, b, _h = http_get(base_url, {"variable": key})
|
||
if st == 200:
|
||
self.ui_queue.put(("update", key, b, st))
|
||
else:
|
||
self.ui_queue.put(("error", key, st, coerce_preview(b, 200)))
|
||
|
||
cycle_dt = time.time() - cycle_start
|
||
remaining = self.refresh_interval - cycle_dt
|
||
if remaining > 0:
|
||
for _ in range(int(remaining * 10)):
|
||
if self.stop_event.is_set():
|
||
break
|
||
while self.paused_event.is_set() and not self.stop_event.is_set():
|
||
time.sleep(0.1)
|
||
time.sleep(0.1)
|
||
|
||
self.ui_queue.put(("stopped", ""))
|
||
|
||
# =====================
|
||
# GUI
|
||
# =====================
|
||
class App(tk.Tk):
|
||
def __init__(self) -> None:
|
||
super().__init__()
|
||
self.title("Control Board Monitor — v1.6")
|
||
self.geometry("1280x860")
|
||
|
||
# Canonical registry: lower-case key -> VarInfo
|
||
self.vars: Dict[str, VarInfo] = {}
|
||
self.stop_event = threading.Event()
|
||
self.paused_event = threading.Event()
|
||
self.ui_queue: queue.Queue = queue.Queue()
|
||
self.poller: Optional[Poller] = None
|
||
self.variables_keys: List[str] = [] # list of lower-case keys in selection order
|
||
self.functions_list: List[str] = [] # preserve original casing
|
||
|
||
self.scheduler = ActionScheduler(lambda: build_base_url(self.host_var.get().strip(), int(self.port_var.get())), self.get_current_value)
|
||
self.scheduler.start()
|
||
|
||
controls = ttk.Frame(self, padding=10)
|
||
controls.pack(side=tk.TOP, fill=tk.X)
|
||
|
||
self.host_var = tk.StringVar(value=SERVER_HOST)
|
||
self.port_var = tk.IntVar(value=SERVER_PORT)
|
||
self.refresh_var = tk.DoubleVar(value=REFRESH_INTERVAL_S)
|
||
self.avg_window_var = tk.IntVar(value=AVERAGE_WINDOW_N)
|
||
|
||
ttk.Label(controls, text="Host:").grid(row=0, column=0, sticky="w")
|
||
ttk.Entry(controls, textvariable=self.host_var, width=16).grid(row=0, column=1, padx=(0, 10))
|
||
ttk.Label(controls, text="Port:").grid(row=0, column=2, sticky="w")
|
||
ttk.Entry(controls, textvariable=self.port_var, width=8).grid(row=0, column=3, padx=(0, 10))
|
||
ttk.Label(controls, text="Refresh (s):").grid(row=0, column=4, sticky="w")
|
||
ttk.Entry(controls, textvariable=self.refresh_var, width=8).grid(row=0, column=5, padx=(0, 10))
|
||
ttk.Label(controls, text="Avg N:").grid(row=0, column=6, sticky="w")
|
||
ttk.Entry(controls, textvariable=self.avg_window_var, width=6).grid(row=0, column=7, padx=(0, 10))
|
||
|
||
self.status_lbl = ttk.Label(controls, text="Idle", foreground="#666")
|
||
self.status_lbl.grid(row=0, column=8, padx=(10, 0))
|
||
|
||
btns = ttk.Frame(controls)
|
||
btns.grid(row=0, column=9, padx=10, sticky="e")
|
||
ttk.Button(btns, text="Select Vars…", command=self.open_selector).grid(row=0, column=0, padx=4)
|
||
ttk.Button(btns, text="Reload (disc.)", command=self.reload_discovery).grid(row=0, column=1, padx=4)
|
||
self.start_btn = ttk.Button(btns, text="Start", command=self.start_polling)
|
||
self.start_btn.grid(row=0, column=2, padx=4)
|
||
self.pause_btn = ttk.Button(btns, text="Pause", command=self.toggle_pause, state="disabled")
|
||
self.pause_btn.grid(row=0, column=3, padx=4)
|
||
|
||
main = ttk.Panedwindow(self, orient=tk.VERTICAL)
|
||
main.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=10, pady=(0,10))
|
||
|
||
search_frame = ttk.Frame(self, padding=(0, 6, 0, 6))
|
||
ttk.Label(search_frame, text="Filter:").pack(side=tk.LEFT)
|
||
self.filter_var = tk.StringVar(value="")
|
||
self.filter_var.trace_add("write", lambda *_: self.refresh_tree())
|
||
ttk.Entry(search_frame, textvariable=self.filter_var, width=50).pack(side=tk.LEFT, padx=8)
|
||
|
||
top_frame = ttk.Frame(main)
|
||
search_frame.pack(in_=top_frame, side=tk.TOP, fill=tk.X)
|
||
columns = ("value", "delta", "davg", "avg", "updated", "status")
|
||
self.tree = ttk.Treeview(top_frame, columns=columns, show="tree headings", height=20, selectmode="browse")
|
||
self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
|
||
vsb = ttk.Scrollbar(top_frame, orient="vertical", command=self.tree.yview)
|
||
vsb.pack(side=tk.RIGHT, fill=tk.Y)
|
||
self.tree.configure(yscrollcommand=vsb.set)
|
||
self._bind_mousewheel(self.tree)
|
||
self.avg_window_var.trace_add("write", lambda *_: (self.tree.heading("avg", text=f"Avg ({self.avg_window_var.get()})"), self.tree.heading("davg", text=f"Δ avg ({self.avg_window_var.get()})")))
|
||
|
||
self.tree.heading("#0", text="Variable")
|
||
self.tree.heading("value", text="Value")
|
||
self.tree.heading("delta", text="Δ last")
|
||
self.tree.heading("davg", text=f"Δ avg ({self.avg_window_var.get()})")
|
||
self.tree.heading("avg", text=f"Avg ({self.avg_window_var.get()})")
|
||
self.tree.heading("updated", text="Updated")
|
||
self.tree.heading("status", text="HTTP")
|
||
|
||
self.tree.column("#0", width=500, anchor="w")
|
||
self.tree.column("value", width=340, anchor="w")
|
||
self.tree.column("delta", width=110, anchor="e")
|
||
self.tree.column("davg", width=120, anchor="e")
|
||
self.tree.column("avg", width=120, anchor="e")
|
||
self.tree.column("updated", width=110, anchor="center")
|
||
self.tree.column("status", width=60, anchor="center")
|
||
|
||
style = ttk.Style(self)
|
||
try: style.theme_use("clam")
|
||
except Exception: pass
|
||
|
||
# Context menu
|
||
self.tree_menu = tk.Menu(self, tearoff=False)
|
||
self.tree_menu.add_command(label="Set thresholds, actions & alarms…", command=self.open_thresholds_dialog)
|
||
self.tree.bind("<Button-3>", self.on_tree_right_click)
|
||
|
||
bottom = ttk.Frame(main)
|
||
|
||
act_controls = ttk.Frame(bottom, padding=(0,6,0,6))
|
||
ttk.Label(act_controls, text="Function:").pack(side=tk.LEFT)
|
||
self.func_name_var = tk.StringVar(value="")
|
||
self.func_combo = ttk.Combobox(act_controls, textvariable=self.func_name_var, width=44)
|
||
self.func_combo.pack(side=tk.LEFT, padx=6)
|
||
self._attach_search_filter_to_combobox(self.func_combo, self.functions_list)
|
||
ttk.Label(act_controls, text="Value:").pack(side=tk.LEFT)
|
||
self.func_value_var = tk.StringVar(value="1")
|
||
ttk.Entry(act_controls, textvariable=self.func_value_var, width=10).pack(side=tk.LEFT, padx=6)
|
||
ttk.Button(act_controls, text="Run Once", command=self.run_func_once).pack(side=tk.LEFT, padx=4)
|
||
ttk.Button(act_controls, text="Schedule…", command=self.add_schedule_dialog).pack(side=tk.LEFT, padx=4)
|
||
|
||
columns2 = ("func", "value", "mode", "interval", "next", "enabled")
|
||
self.actions_tree = ttk.Treeview(bottom, columns=columns2, show="headings", height=10, selectmode="browse")
|
||
for col, hdr, w in zip(columns2, ["Function", "Value", "Mode", "Interval(s)", "Next Run", "Enabled"], [280, 160, 100, 100, 180, 80]):
|
||
self.actions_tree.heading(col, text=hdr)
|
||
self.actions_tree.column(col, width=w, anchor="center")
|
||
|
||
self.actions_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
|
||
vsb2 = ttk.Scrollbar(bottom, orient="vertical", command=self.actions_tree.yview)
|
||
vsb2.pack(side=tk.RIGHT, fill=tk.Y)
|
||
self.actions_tree.configure(yscrollcommand=vsb2.set)
|
||
self._bind_mousewheel(self.actions_tree)
|
||
|
||
main.add(top_frame, weight=3)
|
||
main.add(bottom, weight=2)
|
||
|
||
footer = ttk.Frame(self, padding=10)
|
||
footer.pack(side=tk.BOTTOM, fill=tk.X)
|
||
self.cycle_lbl = ttk.Label(footer, text="Last cycle: —")
|
||
self.cycle_lbl.pack(side=tk.LEFT)
|
||
|
||
self.protocol("WM_DELETE_WINDOW", self.on_close)
|
||
|
||
# Menubar
|
||
menubar = tk.Menu(self)
|
||
filemenu = tk.Menu(menubar, tearoff=False)
|
||
filemenu.add_command(label="Save Configuration...", command=self.save_config)
|
||
filemenu.add_command(label="Load Configuration...", command=self.load_config)
|
||
filemenu.add_separator()
|
||
filemenu.add_command(label="Exit", command=self.on_close)
|
||
menubar.add_cascade(label="File", menu=filemenu)
|
||
|
||
funmenu = tk.Menu(menubar, tearoff=False)
|
||
funmenu.add_command(label="Run Function Once...", command=self.menu_run_once_dialog)
|
||
funmenu.add_command(label="Add Scheduled Function...", command=self.menu_schedule_dialog)
|
||
funmenu.add_separator()
|
||
funmenu.add_command(label="Reload Discovery", command=self.reload_discovery)
|
||
funmenu.add_command(label="Select Variables…", command=self.open_selector)
|
||
menubar.add_cascade(label="Function", menu=funmenu)
|
||
self.config(menu=menubar)
|
||
|
||
|
||
self.functions_list = list(DEFAULT_FUNCTIONS)
|
||
self.func_combo["values"] = self.functions_list
|
||
if self.functions_list and not self.func_name_var.get():
|
||
self.func_name_var.set(self.functions_list[0])
|
||
|
||
# Stable IDs
|
||
self._group_ids: Dict[str, str] = {}
|
||
self._var_ids: Dict[str, str] = {}
|
||
|
||
# Color tag cache: color_hex -> tag_name
|
||
self._color_tags: Dict[str, str] = {}
|
||
# Track repeating actions per (var_key,state)
|
||
self.state_tasks: Dict[tuple, int] = {}
|
||
self.expr_state_tasks: Dict[tuple, int] = {}
|
||
# Latest values from batch (lowercased keys)
|
||
self.latest_values: Dict[str, str] = {}
|
||
self.known_variables: List[str] = []
|
||
|
||
# Trigger discovery shortly after startup so function list populates
|
||
self.after(200, self.reload_discovery)
|
||
|
||
# Live watch for refresh interval changes
|
||
self._last_refresh_val = float(self.refresh_var.get())
|
||
self.after(2000, self._watch_refresh_interval)
|
||
|
||
# Actions context menu
|
||
self.actions_menu = tk.Menu(self, tearoff=False)
|
||
self.actions_menu.add_command(label="Toggle Enable/Disable", command=self.toggle_selected_task)
|
||
self.actions_menu.add_command(label="Run Now", command=self.run_selected_task_now)
|
||
self.actions_menu.add_command(label="Remove", command=self.remove_selected_task)
|
||
self.actions_tree.bind("<Button-3>", self.on_actions_right_click)
|
||
|
||
# --- Discovery ---
|
||
def reload_discovery(self) -> None:
|
||
host = self.host_var.get().strip()
|
||
port = int(self.port_var.get())
|
||
base = build_base_url(host, port)
|
||
|
||
discovered_vars: List[str] = []
|
||
discovered_funcs: List[str] = []
|
||
msgs = []
|
||
|
||
# 1) Functions via WEBSERVER_LIST_VARIABLES_JSON (POST list)
|
||
s1, b1, _1 = http_get(base, {"variable": "WEBSERVER_LIST_VARIABLES_JSON"})
|
||
if s1 == 200 and b1:
|
||
_get_list, post_list = parse_weblist_names(b1)
|
||
if post_list:
|
||
discovered_funcs.extend(post_list)
|
||
else:
|
||
msgs.append(f"LIST_VARIABLES_JSON HTTP {s1}: {coerce_preview(b1,120)}")
|
||
|
||
# 2) Variables via WEBSERVER_BATCH_GET keys
|
||
s2, b2, _2 = http_get(base, {"variable": "WEBSERVER_BATCH_GET"})
|
||
if s2 == 200 and b2:
|
||
values_map = parse_batch_values(b2)
|
||
if values_map:
|
||
seen=set()
|
||
for k in values_map.keys():
|
||
kl = k.lower()
|
||
if kl not in seen:
|
||
seen.add(kl); discovered_vars.append(k)
|
||
else:
|
||
msgs.append(f"BATCH_GET HTTP {s2}: {coerce_preview(b2,120)}")
|
||
|
||
# 3) Fallbacks
|
||
if not discovered_vars or not discovered_funcs:
|
||
s3, b3, _3 = http_get_root(base)
|
||
if s3 == 200 and b3:
|
||
if not discovered_vars:
|
||
discovered_vars = parse_variable_names_from_html_index(b3) or discovered_vars
|
||
if not discovered_funcs:
|
||
discovered_funcs = parse_function_names_from_html_index(b3) or discovered_funcs
|
||
else:
|
||
msgs.append(f"Main page HTTP {s3}: {coerce_preview(b3,120)}")
|
||
|
||
# 4) embedded defaults
|
||
used_defaults = False
|
||
if not discovered_vars:
|
||
discovered_vars = list(DEFAULT_VARS); used_defaults = True
|
||
if not discovered_funcs:
|
||
discovered_funcs = list(DEFAULT_FUNCTIONS)
|
||
|
||
# Apply
|
||
self.functions_list = discovered_funcs
|
||
self.func_combo["values"] = self.functions_list
|
||
if self.functions_list and not self.func_name_var.get():
|
||
self.func_name_var.set(self.functions_list[0])
|
||
# Remember known variables for y/z source selectors
|
||
self.known_variables = list(discovered_vars)
|
||
self.show_selector_dialog(discovered_vars)
|
||
|
||
# Status
|
||
if used_defaults:
|
||
messagebox.showwarning(
|
||
"Discovery fallback",
|
||
"Could not fully discover via LIST_VARIABLES_JSON / BATCH_GET.\n"
|
||
"Loaded embedded defaults so you can proceed.\n\n" + ("\n".join(msgs[:6]) if msgs else ""))
|
||
self.status_lbl.configure(text=f"Loaded defaults ({len(discovered_vars)} vars, {len(discovered_funcs)} funcs)")
|
||
else:
|
||
self.status_lbl.configure(text=f"Discovered: vars {len(discovered_vars)} | funcs {len(discovered_funcs)}")
|
||
|
||
# --- Select Vars dialog ---
|
||
def open_selector(self) -> None:
|
||
union = set([vi.display_name for vi in self.vars.values()]) or set(DEFAULT_VARS)
|
||
self.show_selector_dialog(sorted(union))
|
||
|
||
def show_selector_dialog(self, discovered: List[str]) -> None:
|
||
seen=set(); disp=[]
|
||
for n in discovered:
|
||
kl = n.lower()
|
||
if kl not in seen:
|
||
seen.add(kl); disp.append(n)
|
||
|
||
dlg = tk.Toplevel(self)
|
||
dlg.title("Select Variables to Monitor")
|
||
dlg.geometry("600x540")
|
||
dlg.transient(self)
|
||
dlg.grab_set()
|
||
|
||
temp_selected = {k: True for k in self.variables_keys}
|
||
|
||
top = ttk.Frame(dlg, padding=8)
|
||
top.pack(side=tk.TOP, fill=tk.X)
|
||
ttk.Label(top, text="Filter:").pack(side=tk.LEFT)
|
||
filt_var = tk.StringVar(value="")
|
||
ttk.Entry(top, textvariable=filt_var, width=40).pack(side=tk.LEFT, padx=6)
|
||
sel_all = ttk.Button(top, text="Select All")
|
||
sel_none = ttk.Button(top, text="Clear")
|
||
sel_all.pack(side=tk.LEFT, padx=4); sel_none.pack(side=tk.LEFT, padx=4)
|
||
|
||
frame = ttk.Frame(dlg)
|
||
frame.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=8, pady=8)
|
||
canvas = tk.Canvas(frame, borderwidth=0)
|
||
vsb = ttk.Scrollbar(frame, orient="vertical", command=canvas.yview)
|
||
inner = ttk.Frame(canvas)
|
||
inner.bind("<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
|
||
canvas.create_window((0,0), window=inner, anchor="nw")
|
||
canvas.configure(yscrollcommand=vsb.set)
|
||
canvas.pack(side="left", fill="both", expand=True); vsb.pack(side="right", fill="y")
|
||
|
||
def _mw(event):
|
||
if event.delta:
|
||
canvas.yview_scroll(int(-1*(event.delta/120)), "units")
|
||
return "break"
|
||
def _mw_up(_e):
|
||
canvas.yview_scroll(-1, "units"); return "break"
|
||
def _mw_down(_e):
|
||
canvas.yview_scroll(1, "units"); return "break"
|
||
canvas.bind("<MouseWheel>", _mw)
|
||
inner.bind("<MouseWheel>", _mw)
|
||
canvas.bind("<Button-4>", _mw_up)
|
||
canvas.bind("<Button-5>", _mw_down)
|
||
inner.bind("<Button-4>", _mw_up)
|
||
inner.bind("<Button-5>", _mw_down)
|
||
|
||
rows: List[Tuple[str, str, tk.BooleanVar]] = []
|
||
|
||
def rebuild():
|
||
for child in inner.winfo_children():
|
||
child.destroy()
|
||
rows.clear()
|
||
f = filt_var.get().strip().lower()
|
||
for name in disp:
|
||
if f and f not in name.lower():
|
||
continue
|
||
key = name.lower()
|
||
var = tk.BooleanVar(value=temp_selected.get(key, False))
|
||
def bind_trace(k=key, v=var):
|
||
def _(*_a):
|
||
temp_selected[k] = v.get()
|
||
v.trace_add("write", _)
|
||
bind_trace()
|
||
cb = ttk.Checkbutton(inner, text=name, variable=var)
|
||
cb.pack(anchor="w", pady=2, padx=4)
|
||
rows.append((name, key, var))
|
||
rebuild()
|
||
filt_var.trace_add("write", lambda *_: rebuild())
|
||
|
||
def select_all():
|
||
for _, key, var in rows:
|
||
var.set(True); temp_selected[key] = True
|
||
def clear_all():
|
||
for _, key, var in rows:
|
||
var.set(False); temp_selected[key] = False
|
||
sel_all.configure(command=select_all)
|
||
sel_none.configure(command=clear_all)
|
||
|
||
bot = ttk.Frame(dlg, padding=8)
|
||
bot.pack(side=tk.BOTTOM, fill=tk.X)
|
||
def apply_and_close():
|
||
selected_keys = [k for k, sel in temp_selected.items() if sel]
|
||
new_order = [k for k in self.variables_keys if k in selected_keys]
|
||
for name in disp:
|
||
key = name.lower()
|
||
if temp_selected.get(key, False) and key not in new_order:
|
||
new_order.append(key)
|
||
self.variables_keys = new_order
|
||
new_vars: Dict[str, VarInfo] = {}
|
||
for key in self.variables_keys:
|
||
if key in self.vars:
|
||
vi = self.vars[key]
|
||
else:
|
||
disp_name = next((n for n, k, _ in rows if k == key), key)
|
||
vi = VarInfo(key=key, display_name=disp_name)
|
||
new_vars[key] = vi
|
||
self.vars = new_vars
|
||
# If poller is running, update its live list
|
||
if self.poller and self.poller.is_alive():
|
||
self.poller.variables_keys = self.variables_keys[:]
|
||
self.refresh_tree()
|
||
dlg.destroy()
|
||
ttk.Button(bot, text="Apply", command=apply_and_close).pack(side=tk.RIGHT, padx=4)
|
||
ttk.Button(bot, text="Cancel", command=dlg.destroy).pack(side=tk.RIGHT, padx=4)
|
||
|
||
# --- Actions UI ---
|
||
def on_actions_right_click(self, event):
|
||
try:
|
||
iid = self.actions_tree.identify_row(event.y)
|
||
if iid:
|
||
self.actions_tree.selection_set(iid)
|
||
finally:
|
||
self.actions_menu.tk_popup(event.x_root, event.y_root)
|
||
|
||
def run_func_once(self):
|
||
fname = self.func_name_var.get().strip()
|
||
if not fname:
|
||
messagebox.showinfo("No function", "Choose a function first.")
|
||
return
|
||
val = self.func_value_var.get()
|
||
status, body, _ = self.scheduler.run_once(fname, val)
|
||
messagebox.showinfo("Run Once", f"POST ?variable={fname}&value={val}\nHTTP {status}\n{coerce_preview(body, 300)}")
|
||
|
||
def add_schedule_dialog(self):
|
||
fname = self.func_name_var.get().strip()
|
||
if not fname:
|
||
messagebox.showinfo("No function", "Choose a function first.")
|
||
return
|
||
top = tk.Toplevel(self); top.title("Schedule Function"); top.geometry("360x170"); top.transient(self); top.grab_set()
|
||
ttk.Label(top, text=f"Function: {fname}").pack(pady=(10,4))
|
||
val_var = tk.StringVar(value=self.func_value_var.get())
|
||
ttk.Label(top, text="Value:").pack()
|
||
ttk.Entry(top, textvariable=val_var, width=16).pack()
|
||
int_var = tk.DoubleVar(value=1.0)
|
||
ttk.Label(top, text="Interval (seconds):").pack(pady=(6,0))
|
||
ttk.Entry(top, textvariable=int_var, width=10).pack()
|
||
|
||
def add_it():
|
||
interval = float(int_var.get())
|
||
task = ActionTask(name=fname, value=val_var.get(), interval_s=max(0.0, interval))
|
||
tid = self.scheduler.add_task(task)
|
||
self.refresh_actions_tree()
|
||
top.destroy()
|
||
ttk.Button(top, text="Add", command=add_it).pack(pady=10)
|
||
|
||
def toggle_selected_task(self):
|
||
sel = self.actions_tree.selection()
|
||
if not sel: return
|
||
tid = int(sel[0])
|
||
tasks = {t.task_id: t for t in self.scheduler.list_tasks()}
|
||
t = tasks.get(tid);
|
||
if not t: return
|
||
self.scheduler.set_enabled(tid, not t.enabled)
|
||
self.refresh_actions_tree()
|
||
|
||
def run_selected_task_now(self):
|
||
sel = self.actions_tree.selection()
|
||
if not sel: return
|
||
tid = int(sel[0])
|
||
tasks = {t.task_id: t for t in self.scheduler.list_tasks()}
|
||
t = tasks.get(tid)
|
||
if not t: return
|
||
status, body, _ = self.scheduler.run_task_once(t)
|
||
messagebox.showinfo("Run Now", f"POST ?variable={t.name}&value={t.value}\nHTTP {status}\n{coerce_preview(body, 300)}")
|
||
|
||
def remove_selected_task(self):
|
||
sel = self.actions_tree.selection()
|
||
if not sel: return
|
||
tid = int(sel[0])
|
||
self.scheduler.remove_task(tid)
|
||
self.refresh_actions_tree()
|
||
|
||
|
||
def get_current_value(self, name: Optional[str]) -> Optional[float]:
|
||
if not name:
|
||
return None
|
||
key = str(name).lower()
|
||
if hasattr(self, "latest_values") and key in self.latest_values:
|
||
return parse_first_float(self.latest_values.get(key))
|
||
base = build_base_url(self.host_var.get().strip(), int(self.port_var.get()))
|
||
st, bd, _h = http_get(base, {"variable": key})
|
||
if st == 200:
|
||
return parse_first_float(bd)
|
||
return None
|
||
def refresh_actions_tree(self):
|
||
self.actions_tree.delete(*self.actions_tree.get_children())
|
||
for t in self.scheduler.list_tasks():
|
||
mode = ("Interval" if t.interval_s > 0 else "Once") + (" + Expr" if getattr(t, 'expr', None) else "")
|
||
next_s = ("—" if t.interval_s == 0 else datetime.fromtimestamp(t.next_run).strftime("%H:%M:%S"))
|
||
self.actions_tree.insert("", "end", iid=str(t.task_id), values=(t.name, t.value, mode, t.interval_s, next_s, "Yes" if t.enabled else "No"))
|
||
|
||
# --- Poller control / rendering ---
|
||
def start_polling(self) -> None:
|
||
if hasattr(self, "poller") and self.poller and self.poller.is_alive():
|
||
messagebox.showinfo("Already running", "Polling is already active.")
|
||
return
|
||
if not self.variables_keys:
|
||
messagebox.showwarning("No variables", "Variable list is empty. Use Select Vars… first.")
|
||
return
|
||
self.stop_event.clear()
|
||
self.paused_event.clear()
|
||
self.poller = Poller(
|
||
host=self.host_var.get().strip(),
|
||
port=int(self.port_var.get()),
|
||
variables_keys=self.variables_keys,
|
||
ui_queue=self.ui_queue,
|
||
refresh_interval=float(self.refresh_var.get()),
|
||
stop_event=self.stop_event,
|
||
paused_event=self.paused_event,
|
||
)
|
||
self.poller.start()
|
||
self.start_btn.configure(state="disabled")
|
||
self.pause_btn.configure(state="normal", text="Pause")
|
||
self.status_lbl.configure(text="Running…")
|
||
self.after(100, self.drain_queue)
|
||
|
||
def toggle_pause(self) -> None:
|
||
if not (self.poller and self.poller.is_alive()):
|
||
return
|
||
if self.paused_event.is_set():
|
||
self.paused_event.clear()
|
||
self.pause_btn.configure(text="Pause")
|
||
self.status_lbl.configure(text="Running…")
|
||
else:
|
||
self.paused_event.set()
|
||
self.pause_btn.configure(text="Resume")
|
||
self.status_lbl.configure(text="Paused")
|
||
|
||
def drain_queue(self) -> None:
|
||
try:
|
||
while True:
|
||
item = self.ui_queue.get_nowait()
|
||
kind = item[0]
|
||
if kind == "update":
|
||
_, key, value, status = item
|
||
vi = self.vars.get(key)
|
||
if not vi:
|
||
vi = VarInfo(key=key, display_name=key)
|
||
prev_num = parse_first_float(vi.last_value)
|
||
curr_num = parse_first_float(value)
|
||
vi.last_value = value
|
||
vi.last_updated = time.time()
|
||
vi.last_status = status
|
||
vi.error = None
|
||
# analytics update
|
||
if prev_num is not None and curr_num is not None:
|
||
vi.delta_last = curr_num - prev_num
|
||
try:
|
||
vi.history_delta.append(vi.delta_last)
|
||
except Exception:
|
||
pass
|
||
else:
|
||
vi.delta_last = None
|
||
if curr_num is not None:
|
||
try:
|
||
vi.history.append(curr_num)
|
||
except Exception:
|
||
pass
|
||
self.vars[key] = vi
|
||
self.evaluate_thresholds(vi, value)
|
||
elif kind == "error":
|
||
_, key, status, msg = item
|
||
vi = self.vars.get(key) or VarInfo(key=key, display_name=key)
|
||
vi.last_status = status
|
||
vi.error = msg
|
||
vi.last_updated = time.time()
|
||
self.vars[key] = vi
|
||
elif kind == "cycle_start":
|
||
_, hhmmss = item
|
||
self.cycle_lbl.configure(text=f"Last cycle start: {hhmmss}")
|
||
elif kind == "batch":
|
||
_, mapping = item
|
||
if isinstance(mapping, dict):
|
||
self.latest_values.update(mapping)
|
||
# refresh known_variables list from batch keys (preserve case with existing where possible)
|
||
keys = list(mapping.keys())
|
||
# prefer existing display names from self.vars, else use given keys
|
||
disp = [self.vars.get(k.lower()).display_name if self.vars.get(k.lower()) else k for k in keys]
|
||
self.known_variables = sorted(set(list(self.known_variables) + disp), key=str.lower)
|
||
elif kind == "stopped":
|
||
self.status_lbl.configure(text="Stopped")
|
||
elif kind == "batch_fmt":
|
||
_, fmt = item
|
||
# nie nadpisuj info o błędach/paused – tylko dołóż sufiks
|
||
cur = self.status_lbl.cget("text") or ""
|
||
base = cur.split(" | ")[0] # zachowaj, co było przedtem
|
||
self.status_lbl.configure(text=f"{base} | batch: {fmt}")
|
||
self.ui_queue.task_done()
|
||
except queue.Empty:
|
||
pass
|
||
self.refresh_tree()
|
||
self.refresh_actions_tree()
|
||
if self.poller and self.poller.is_alive():
|
||
self.after(250, self.drain_queue)
|
||
|
||
# --- Threshold logic & rendering ---
|
||
def on_tree_right_click(self, event):
|
||
try:
|
||
iid = self.tree.identify_row(event.y)
|
||
if iid:
|
||
self.tree.selection_set(iid)
|
||
finally:
|
||
self.tree_menu.tk_popup(event.x_root, event.y_root)
|
||
|
||
|
||
def open_thresholds_dialog(self):
|
||
sel = self.tree.selection()
|
||
if not sel:
|
||
messagebox.showinfo("No selection", "Select a variable first.")
|
||
return
|
||
iid = sel[0]
|
||
if not iid.startswith("var:"):
|
||
messagebox.showinfo("Select variable", "Select a specific variable row (not a group).")
|
||
return
|
||
key = iid.split("var:",1)[1]
|
||
vi = self.vars.get(key)
|
||
if not vi:
|
||
messagebox.showinfo("Missing", "Selected variable is not available.")
|
||
return
|
||
|
||
dlg = tk.Toplevel(self)
|
||
dlg.title(f"Thresholds, actions & alarms — {vi.display_name}")
|
||
dlg.geometry("980x700")
|
||
dlg.transient(self); dlg.grab_set()
|
||
|
||
t = vi.thresholds
|
||
cur = parse_first_float(vi.last_value)
|
||
auto_defaults = {}
|
||
if cur is not None:
|
||
auto_defaults = {"dead_low": round(cur*0.8, 6), "low": round(cur*0.9, 6), "high": round(cur*1.1, 6), "extreme_high": round(cur*1.2, 6)}
|
||
|
||
# Scrollable body
|
||
outer = ttk.Frame(dlg); outer.pack(fill=tk.BOTH, expand=True)
|
||
canvas = tk.Canvas(outer, highlightthickness=0)
|
||
vsb = ttk.Scrollbar(outer, orient="vertical", command=canvas.yview)
|
||
canvas.configure(yscrollcommand=vsb.set)
|
||
vsb.pack(side=tk.RIGHT, fill=tk.Y)
|
||
canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
|
||
grid = ttk.Frame(canvas)
|
||
win = canvas.create_window((0,0), window=grid, anchor="nw")
|
||
def _on_cfg(event=None):
|
||
canvas.configure(scrollregion=canvas.bbox("all"))
|
||
canvas.itemconfigure(win, width=canvas.winfo_width())
|
||
grid.bind("<Configure>", _on_cfg)
|
||
canvas.bind("<Configure>", _on_cfg)
|
||
|
||
# thresholds
|
||
ttk.Label(grid, text="DEAD LOW").grid(row=0, column=0, sticky="w", pady=2)
|
||
ttk.Label(grid, text="LOW").grid(row=1, column=0, sticky="w", pady=2)
|
||
ttk.Label(grid, text="HIGH").grid(row=2, column=0, sticky="w", pady=2)
|
||
ttk.Label(grid, text="EXTREME HIGH").grid(row=3, column=0, sticky="w", pady=2)
|
||
|
||
def mk_val(default, keyname, row):
|
||
dv = auto_defaults.get(keyname) if default is None else default
|
||
sv = tk.StringVar(value="" if dv is None else str(dv))
|
||
ttk.Entry(grid, textvariable=sv, width=12).grid(row=row, column=1, sticky="w", padx=6)
|
||
return sv
|
||
dead_low_var = mk_val(t.dead_low, "dead_low", 0)
|
||
low_var = mk_val(t.low, "low", 1)
|
||
high_var = mk_val(t.high, "high", 2)
|
||
extreme_high_var = mk_val(t.extreme_high, "extreme_high", 3)
|
||
|
||
ttk.Label(grid, text="Alarm on enter:").grid(row=0, column=3, sticky="w")
|
||
alarm_dead_low = tk.BooleanVar(value=t.alarm_dead_low)
|
||
alarm_low = tk.BooleanVar(value=t.alarm_low)
|
||
alarm_high = tk.BooleanVar(value=t.alarm_high)
|
||
alarm_ext = tk.BooleanVar(value=t.alarm_extreme_high)
|
||
ttk.Checkbutton(grid, text="Dead Low", variable=alarm_dead_low).grid(row=1, column=3, sticky="w")
|
||
ttk.Checkbutton(grid, text="Low", variable=alarm_low).grid(row=2, column=3, sticky="w")
|
||
ttk.Checkbutton(grid, text="High", variable=alarm_high).grid(row=3, column=3, sticky="w")
|
||
ttk.Checkbutton(grid, text="Extreme High", variable=alarm_ext).grid(row=4, column=3, sticky="w")
|
||
|
||
# actions
|
||
ttk.Label(grid, text="On enter: call function (optional)").grid(row=6, column=0, sticky="w", pady=(12,4))
|
||
ttk.Label(grid, text="Interval(s) while in state (0 = once)").grid(row=6, column=3, sticky="w")
|
||
|
||
rows = [("Dead Low", "action_dead_low", "value_dead_low", "action_dead_low_interval"),
|
||
("Low", "action_low", "value_low", "action_low_interval"),
|
||
("Operating", "action_operating", "value_operating", "action_operating_interval"),
|
||
("High", "action_high", "value_high", "action_high_interval"),
|
||
("Extreme High", "action_extreme_high", "value_extreme_high", "action_extreme_high_interval")]
|
||
action_vars = {}; value_vars = {}; interval_vars = {}
|
||
for i, (label, action_key, value_key, interval_key) in enumerate(rows):
|
||
r = 7+i
|
||
ttk.Label(grid, text=label).grid(row=r, column=0, sticky="w", pady=2)
|
||
s = ttk.Combobox(grid, values=self.functions_list or DEFAULT_FUNCTIONS, width=44)
|
||
s.set(getattr(t, action_key) or "")
|
||
s.grid(row=r, column=1, sticky="w", padx=6)
|
||
self._attach_search_filter_to_combobox(s, self.functions_list)
|
||
action_vars[action_key] = s
|
||
sv = tk.StringVar(value=getattr(t, value_key))
|
||
ttk.Entry(grid, textvariable=sv, width=12).grid(row=r, column=2, sticky="w", padx=6)
|
||
value_vars[value_key] = sv
|
||
iv = tk.DoubleVar(value=getattr(t, interval_key) if getattr(t, interval_key) is not None else 1.0)
|
||
ttk.Entry(grid, textvariable=iv, width=10).grid(row=r, column=3, sticky="w", padx=6)
|
||
interval_vars[interval_key] = iv
|
||
|
||
# y/z sources
|
||
ttk.Label(grid, text="y source (optional)").grid(row=13, column=0, sticky="w", pady=(14,4))
|
||
y_source_var = tk.StringVar(value=t.y_source or "")
|
||
y_combo = ttk.Combobox(grid, values=(self.known_variables or [vi.display_name]), textvariable=y_source_var, width=44)
|
||
y_combo.grid(row=13, column=1, sticky="w", padx=6)
|
||
self._attach_search_filter_to_combobox(y_combo, self.known_variables)
|
||
ttk.Label(grid, text="z source (optional)").grid(row=13, column=2, sticky="e")
|
||
z_source_var = tk.StringVar(value=t.z_source or "")
|
||
z_combo = ttk.Combobox(grid, values=(self.known_variables or [vi.display_name]), textvariable=z_source_var, width=32)
|
||
z_combo.grid(row=13, column=3, sticky="w", padx=6)
|
||
self._attach_search_filter_to_combobox(z_combo, self.known_variables)
|
||
|
||
# expressions
|
||
ttk.Label(grid, text="On enter: evaluate expression/snippet (x, y, z available) and optionally POST to a function").grid(row=15, column=0, sticky="w", pady=(14,4), columnspan=3)
|
||
expr_rows = [("Dead Low expr", "expr_dead_low", "expr_target_dead_low"),
|
||
("Low expr", "expr_low", "expr_target_low"),
|
||
("Operating expr", "expr_operating", "expr_target_operating"),
|
||
("High expr", "expr_high", "expr_target_high"),
|
||
("Extreme High expr", "expr_extreme_high", "expr_target_extreme_high")]
|
||
expr_vars = {}; expr_target_vars = {}
|
||
for i, (label, keyname, tkey) in enumerate(expr_rows):
|
||
r = 16+i
|
||
ttk.Label(grid, text=label).grid(row=r, column=0, sticky="w", pady=2)
|
||
expr_vars[keyname] = tk.StringVar(value=getattr(t, keyname) or "")
|
||
ttk.Entry(grid, textvariable=expr_vars[keyname], width=64).grid(row=r, column=1, sticky="w", padx=6)
|
||
ttk.Label(grid, text="→ POST to function").grid(row=r, column=2, sticky="e")
|
||
s = ttk.Combobox(grid, values=self.functions_list or DEFAULT_FUNCTIONS, width=32)
|
||
s.set(getattr(t, tkey) or "")
|
||
s.grid(row=r, column=3, sticky="w", padx=6)
|
||
self._attach_search_filter_to_combobox(s, self.functions_list)
|
||
expr_target_vars[tkey] = s
|
||
|
||
# Bottom bar
|
||
btns = ttk.Frame(dlg); btns.pack(fill=tk.X, padx=10, pady=10)
|
||
def do_save():
|
||
nt = Thresholds(
|
||
dead_low=parse_first_float(dead_low_var.get() or None),
|
||
low=parse_first_float(low_var.get() or None),
|
||
high=parse_first_float(high_var.get() or None),
|
||
extreme_high=parse_first_float(extreme_high_var.get() or None),
|
||
alarm_dead_low=bool(alarm_dead_low.get()),
|
||
alarm_low=bool(alarm_low.get()),
|
||
alarm_high=bool(alarm_high.get()),
|
||
alarm_extreme_high=bool(alarm_ext.get()),
|
||
action_dead_low=action_vars["action_dead_low"].get() or None,
|
||
value_dead_low=value_vars["value_dead_low"].get(),
|
||
action_dead_low_interval=float(interval_vars["action_dead_low_interval"].get() or 1.0),
|
||
action_low=action_vars["action_low"].get() or None,
|
||
value_low=value_vars["value_low"].get(),
|
||
action_low_interval=float(interval_vars["action_low_interval"].get() or 1.0),
|
||
action_operating=action_vars["action_operating"].get() or None,
|
||
value_operating=value_vars["value_operating"].get(),
|
||
action_operating_interval=float(interval_vars["action_operating_interval"].get() or 1.0),
|
||
action_high=action_vars["action_high"].get() or None,
|
||
value_high=value_vars["value_high"].get(),
|
||
action_high_interval=float(interval_vars["action_high_interval"].get() or 1.0),
|
||
action_extreme_high=action_vars["action_extreme_high"].get() or None,
|
||
value_extreme_high=value_vars["value_extreme_high"].get(),
|
||
action_extreme_high_interval=float(interval_vars["action_extreme_high_interval"].get() or 1.0),
|
||
expr_dead_low=(expr_vars["expr_dead_low"].get().strip() or None),
|
||
expr_low=(expr_vars["expr_low"].get().strip() or None),
|
||
expr_operating=(expr_vars["expr_operating"].get().strip() or None),
|
||
expr_high=(expr_vars["expr_high"].get().strip() or None),
|
||
expr_extreme_high=(expr_vars["expr_extreme_high"].get().strip() or None),
|
||
expr_target_dead_low=(expr_target_vars["expr_target_dead_low"].get().strip() or None),
|
||
expr_target_low=(expr_target_vars["expr_target_low"].get().strip() or None),
|
||
expr_target_operating=(expr_target_vars["expr_target_operating"].get().strip() or None),
|
||
expr_target_high=(expr_target_vars["expr_target_high"].get().strip() or None),
|
||
expr_target_extreme_high=(expr_target_vars["expr_target_extreme_high"].get().strip() or None),
|
||
y_source=(y_source_var.get().strip() or None),
|
||
z_source=(z_source_var.get().strip() or None),
|
||
)
|
||
vi.thresholds = nt
|
||
dlg.destroy()
|
||
|
||
ttk.Button(btns, text="Save", command=do_save).pack(side=tk.RIGHT, padx=6)
|
||
ttk.Button(btns, text="Cancel", command=dlg.destroy).pack(side=tk.RIGHT)
|
||
|
||
def evaluate_thresholds(self, vi: VarInfo, value: str) -> None:
|
||
x = parse_first_float(value)
|
||
|
||
t = vi.thresholds
|
||
# Auto-defaults based on current value if thresholds are empty
|
||
cur = parse_first_float(vi.last_value)
|
||
auto_defaults = {}
|
||
if cur is not None:
|
||
auto_defaults = {
|
||
"dead_low": round(cur * 0.8, 6),
|
||
"low": round(cur * 0.9, 6),
|
||
"high": round(cur * 1.1, 6),
|
||
"extreme_high": round(cur * 1.2, 6),
|
||
}
|
||
|
||
prev = vi.last_state
|
||
state = "UNKNOWN"
|
||
|
||
if x is None or (t.low is None and t.high is None and t.dead_low is None and t.extreme_high is None):
|
||
state = "OPERATING"
|
||
else:
|
||
dl = t.dead_low if t.dead_low is not None else -float("inf")
|
||
lo = t.low if t.low is not None else -float("inf")
|
||
hi = t.high if t.high is not None else float("inf")
|
||
ex = t.extreme_high if t.extreme_high is not None else float("inf")
|
||
|
||
if x < dl:
|
||
state = "DEAD_LOW"
|
||
elif x < lo:
|
||
state = "LOW"
|
||
elif x < hi:
|
||
state = "OPERATING"
|
||
elif x < ex:
|
||
state = "HIGH"
|
||
else:
|
||
state = "EXTREME_HIGH"
|
||
|
||
if state != prev:
|
||
self.on_state_change(vi, prev, state, x)
|
||
vi.last_state = state
|
||
|
||
|
||
def on_state_change(self, vi: VarInfo, prev_state: str, new_state: str, x: Optional[float]) -> None:
|
||
# stop any repeating task associated with previous state
|
||
tid = self.state_tasks.pop((vi.key, prev_state), None)
|
||
if tid is not None:
|
||
try:
|
||
self.scheduler.remove_task(tid)
|
||
except Exception:
|
||
pass
|
||
# stop any repeating expr task for previous state
|
||
etid = self.expr_state_tasks.pop((vi.key, prev_state), None)
|
||
if etid is not None:
|
||
try:
|
||
self.scheduler.remove_task(etid)
|
||
except Exception:
|
||
pass
|
||
# then handle enter actions for new_state
|
||
self.on_enter_state(vi, new_state, x)
|
||
def on_enter_state(self, vi: VarInfo, state: str, x: Optional[float]) -> None:
|
||
|
||
t = vi.thresholds
|
||
# Auto-defaults based on current value if thresholds are empty
|
||
cur = parse_first_float(vi.last_value)
|
||
auto_defaults = {}
|
||
if cur is not None:
|
||
auto_defaults = {
|
||
"dead_low": round(cur * 0.8, 6),
|
||
"low": round(cur * 0.9, 6),
|
||
"high": round(cur * 1.1, 6),
|
||
"extreme_high": round(cur * 1.2, 6),
|
||
}
|
||
|
||
alarm_map = {
|
||
"DEAD_LOW": t.alarm_dead_low,
|
||
"LOW": t.alarm_low,
|
||
"OPERATING": False,
|
||
"HIGH": t.alarm_high,
|
||
"EXTREME_HIGH": t.alarm_extreme_high,
|
||
}
|
||
if alarm_map.get(state):
|
||
try:
|
||
import winsound
|
||
freq = {"DEAD_LOW": 350, "LOW": 550, "HIGH": 800, "EXTREME_HIGH": 1000}.get(state, 600)
|
||
dur = 400 if state in ("DEAD_LOW", "EXTREME_HIGH") else 300
|
||
winsound.Beep(freq, dur)
|
||
except Exception:
|
||
try: self.bell()
|
||
except Exception: pass
|
||
|
||
expr_key = {
|
||
"DEAD_LOW": "expr_dead_low", "LOW": "expr_low",
|
||
"HIGH": "expr_high", "EXTREME_HIGH": "expr_extreme_high"
|
||
}.get(state)
|
||
target_key = {
|
||
"DEAD_LOW": "expr_target_dead_low", "LOW": "expr_target_low",
|
||
"HIGH": "expr_target_high", "EXTREME_HIGH": "expr_target_extreme_high"
|
||
}.get(state)
|
||
|
||
expr = getattr(t, expr_key) if expr_key else None
|
||
target_func = getattr(t, target_key) if target_key else None
|
||
# Determine y/z current values (prefer explicit sources)
|
||
y_val = None; z_val = None
|
||
y_source = (t.y_source or '').strip() or None
|
||
z_source = (t.z_source or '').strip() or None
|
||
if not y_source:
|
||
if target_func:
|
||
y_source = target_func
|
||
else:
|
||
action_map = {"DEAD_LOW": t.action_dead_low, "LOW": t.action_low, "HIGH": t.action_high, "EXTREME_HIGH": t.action_extreme_high}
|
||
y_source = action_map.get(state)
|
||
for label, src_name in (('y', y_source), ('z', z_source)):
|
||
if not src_name: continue
|
||
key = src_name.lower()
|
||
val = None
|
||
if hasattr(self, 'latest_values') and key in self.latest_values:
|
||
val = parse_first_float(self.latest_values.get(key))
|
||
else:
|
||
base = build_base_url(self.host_var.get().strip(), int(self.port_var.get()))
|
||
st, bd, _h = http_get(base, {"variable": key})
|
||
if st == 200:
|
||
val = parse_first_float(bd)
|
||
if label == 'y': y_val = val
|
||
else: z_val = val
|
||
if expr and x is not None:
|
||
try:
|
||
computed = eval_user_expression(expr, x, y_val, z_val)
|
||
if target_func:
|
||
base = build_base_url(self.host_var.get().strip(), int(self.port_var.get()))
|
||
params = {"variable": target_func, "value": str(computed)}
|
||
http_post_query(base, params)
|
||
else:
|
||
self.status_lbl.configure(text=f"Expr computed for {vi.display_name} [{state}], no target function set")
|
||
except Exception as e:
|
||
messagebox.showwarning("Expression error", f"{vi.display_name}: expression failed on enter {state}: {e}")
|
||
|
||
act_map = {
|
||
"DEAD_LOW": (t.action_dead_low, t.value_dead_low),
|
||
"LOW": (t.action_low, t.value_low),
|
||
"OPERATING": (t.action_operating, t.value_operating),
|
||
"HIGH": (t.action_high, t.value_high),
|
||
"EXTREME_HIGH": (t.action_extreme_high, t.value_extreme_high),
|
||
}
|
||
act, val = act_map.get(state, (None, "1"))
|
||
if act:
|
||
# Once on enter if interval == 0
|
||
interval_map = {
|
||
"DEAD_LOW": t.action_dead_low_interval,
|
||
"LOW": t.action_low_interval,
|
||
"OPERATING": t.action_operating_interval,
|
||
"HIGH": t.action_high_interval,
|
||
"EXTREME_HIGH": t.action_extreme_high_interval,
|
||
}
|
||
interval = float(interval_map.get(state, 0) or 0.0)
|
||
if interval <= 0.0:
|
||
self.scheduler.add_task(ActionTask(name=act, value=val, interval_s=0.0))
|
||
else:
|
||
tid = self.scheduler.add_task(ActionTask(name=act, value=val, interval_s=max(0.0, interval)))
|
||
self.state_tasks[(vi.key, state)] = tid
|
||
|
||
# Expression scheduling while in state
|
||
expr_key_map = {
|
||
"DEAD_LOW": ("expr_dead_low", "expr_target_dead_low"),
|
||
"LOW": ("expr_low", "expr_target_low"),
|
||
"OPERATING": ("expr_operating", "expr_target_operating"),
|
||
"HIGH": ("expr_high", "expr_target_high"),
|
||
"EXTREME_HIGH": ("expr_extreme_high", "expr_target_extreme_high"),
|
||
}
|
||
ekey, tkey = expr_key_map.get(state, (None, None))
|
||
expr_str = getattr(t, ekey) if ekey else None
|
||
expr_target = getattr(t, tkey) if tkey else None
|
||
if expr_str and expr_target:
|
||
# Use action intervals as default pacing for expressions
|
||
expr_interval = {
|
||
"DEAD_LOW": t.action_dead_low_interval,
|
||
"LOW": t.action_low_interval,
|
||
"OPERATING": t.action_operating_interval,
|
||
"HIGH": t.action_high_interval,
|
||
"EXTREME_HIGH": t.action_extreme_high_interval,
|
||
}.get(state, 1.0) or 1.0
|
||
|
||
if expr_interval <= 0.0:
|
||
# compute once on enter (already computed above in expressions block),
|
||
# but ensure it posts now via scheduler so behavior is consistent
|
||
task = ActionTask(name=expr_target, value="", interval_s=0.0, expr=expr_str,
|
||
x_src=vi.key, y_src=t.y_source, z_src=t.z_source)
|
||
self.scheduler.add_task(task)
|
||
else:
|
||
# schedule repeating expression task
|
||
task = ActionTask(name=expr_target, value="", interval_s=max(0.0, float(expr_interval)), expr=expr_str,
|
||
x_src=vi.key, y_src=t.y_source, z_src=t.z_source)
|
||
tid = self.scheduler.add_task(task)
|
||
self.expr_state_tasks[(vi.key, state)] = tid
|
||
|
||
# --- Tree helpers & rendering ---
|
||
def _ensure_group(self, group: str) -> str:
|
||
iid = self._group_ids.get(group)
|
||
if iid and self.tree.exists(iid):
|
||
return iid
|
||
iid = f"grp:{group}"
|
||
self._group_ids[group] = iid
|
||
if not self.tree.exists(iid):
|
||
self.tree.insert("", "end", iid=iid, text=group, values=("", "", ""), open=True)
|
||
return iid
|
||
|
||
def _ensure_var(self, group_iid: str, key: str, display_name: str) -> str:
|
||
iid = self._var_ids.get(key)
|
||
if iid and self.tree.exists(iid):
|
||
return iid
|
||
iid = f"var:{key}"
|
||
self._var_ids[key] = iid
|
||
if not self.tree.exists(iid):
|
||
self.tree.insert(group_iid, "end", iid=iid, text=display_name, values=("", "", ""))
|
||
return iid
|
||
|
||
def _get_color_tag(self, hex_color: str) -> str:
|
||
tag = self._color_tags.get(hex_color)
|
||
if tag:
|
||
return tag
|
||
tag = f"col_{hex_color[1:]}"
|
||
self._color_tags[hex_color] = tag
|
||
try:
|
||
self.tree.tag_configure(tag, background=hex_color)
|
||
except Exception:
|
||
pass
|
||
return tag
|
||
|
||
def _state_color(self, vi: VarInfo, x: Optional[float]) -> str:
|
||
|
||
t = vi.thresholds
|
||
# Auto-defaults based on current value if thresholds are empty
|
||
cur = parse_first_float(vi.last_value)
|
||
auto_defaults = {}
|
||
if cur is not None:
|
||
auto_defaults = {
|
||
"dead_low": round(cur * 0.8, 6),
|
||
"low": round(cur * 0.9, 6),
|
||
"high": round(cur * 1.1, 6),
|
||
"extreme_high": round(cur * 1.2, 6),
|
||
}
|
||
|
||
if x is None:
|
||
return "#f5f7fb"
|
||
def ci(v): return max(0, min(255, int(v)))
|
||
if t.low is not None and t.high is not None and t.dead_low is not None and t.extreme_high is not None:
|
||
if x < t.dead_low:
|
||
return "#FFC266"
|
||
elif x < t.low:
|
||
span = max(1e-9, t.low - t.dead_low)
|
||
frac = 1.0 - (x - t.dead_low) / span
|
||
r = 255
|
||
g = 248 - frac * (248 - 226)
|
||
b = 204 - frac * (204 - 138)
|
||
return f"#{ci(r):02X}{ci(g):02X}{ci(b):02X}"
|
||
elif x < t.high:
|
||
return "#E6F5E6"
|
||
elif x < t.extreme_high:
|
||
span = max(1e-9, t.extreme_high - t.high)
|
||
frac = (x - t.high) / span
|
||
r = 255
|
||
g = 214 - frac * (214 - 158)
|
||
b = 214 - frac * (214 - 158)
|
||
return f"#{ci(r):02X}{ci(g):02X}{ci(b):02X}"
|
||
else:
|
||
return "#FF6B6B"
|
||
return "#E6F5E6"
|
||
|
||
def refresh_tree(self) -> None:
|
||
filt = self.filter_var.get().strip().lower()
|
||
groups: Dict[str, List[VarInfo]] = {}
|
||
for key, vi in self.vars.items():
|
||
text = vi.display_name
|
||
if filt and filt not in text.lower() and (not vi.last_value or filt not in vi.last_value.lower()):
|
||
continue
|
||
prefix = text.split("_", 1)[0] if "_" in text else "MISC"
|
||
groups.setdefault(prefix, []).append(vi)
|
||
|
||
sel = self.tree.selection()
|
||
sel_iid = sel[0] if sel else None
|
||
|
||
valid_var_iids = set()
|
||
valid_group_iids = set()
|
||
|
||
for g in sorted(groups.keys(), key=lambda s: s.lower()):
|
||
gid = self._ensure_group(g)
|
||
valid_group_iids.add(gid)
|
||
for vi in sorted(groups[g], key=lambda x: x.display_name.lower()):
|
||
vid = self._ensure_var(gid, vi.key, vi.display_name)
|
||
valid_var_iids.add(vid)
|
||
|
||
updated_str = "—"
|
||
if vi.last_updated:
|
||
updated_str = datetime.fromtimestamp(vi.last_updated).strftime("%H:%M:%S")
|
||
|
||
if vi.error:
|
||
value_preview = f"[ERR] {vi.error}"
|
||
else:
|
||
value_preview = coerce_preview(vi.last_value, 120)
|
||
|
||
# Δ last
|
||
delta_str = "N/A"
|
||
if vi.delta_last is not None:
|
||
try:
|
||
delta_str = f"{vi.delta_last:+.6g}"
|
||
except Exception:
|
||
delta_str = str(vi.delta_last)
|
||
|
||
# Δ avg(N)
|
||
davg_str = "N/A"
|
||
try:
|
||
n = max(1, int(self.avg_window_var.get()))
|
||
except Exception:
|
||
n = AVERAGE_WINDOW_N
|
||
if hasattr(vi, "history_delta") and vi.history_delta:
|
||
dvals = list(vi.history_delta)[-n:]
|
||
if len(dvals) >= n:
|
||
try:
|
||
davg_val = sum(dvals) / float(n)
|
||
davg_str = f"{davg_val:.6g}"
|
||
except Exception:
|
||
davg_str = "N/A"
|
||
|
||
# value avg(N)
|
||
avg_str = "N/A"
|
||
if hasattr(vi, "history") and vi.history:
|
||
vals = list(vi.history)[-n:]
|
||
if len(vals) >= n:
|
||
try:
|
||
avg_val = sum(vals) / float(n)
|
||
avg_str = f"{avg_val:.6g}"
|
||
except Exception:
|
||
avg_str = "N/A"
|
||
|
||
x = parse_first_float(vi.last_value)
|
||
color = self._state_color(vi, x)
|
||
tag = self._get_color_tag(color)
|
||
|
||
self.tree.item(vid, text=vi.display_name, values=(value_preview, delta_str, davg_str, avg_str, updated_str, vi.last_status or "—"), tags=(tag,))
|
||
|
||
for key, vid in list(self._var_ids.items()):
|
||
if vid not in valid_var_iids and self.tree.exists(vid):
|
||
self.tree.delete(vid); self._var_ids.pop(key, None)
|
||
for g, gid in list(self._group_ids.items()):
|
||
if gid not in valid_group_iids and self.tree.exists(gid):
|
||
self.tree.delete(gid); self._group_ids.pop(g, None)
|
||
|
||
if sel_iid and self.tree.exists(sel_iid):
|
||
self.tree.selection_set(sel_iid)
|
||
|
||
|
||
def _attach_search_filter_to_combobox(self, combo: ttk.Combobox, source: List[str] | None):
|
||
if source is None:
|
||
source = []
|
||
original = list(source)
|
||
combo.configure(state="normal") # allow typing to filter
|
||
def on_key(_event=None):
|
||
text = combo.get()
|
||
vals = [v for v in original if text.lower() in v.lower()]
|
||
combo["values"] = vals if vals else original
|
||
combo.bind("<KeyRelease>", on_key)
|
||
def _bind_mousewheel(self, widget):
|
||
def _mw(event):
|
||
if event.delta:
|
||
widget.yview_scroll(int(-1*(event.delta/120)), "units")
|
||
return "break"
|
||
def _mw_up(_e):
|
||
widget.yview_scroll(-1, "units"); return "break"
|
||
def _mw_down(_e):
|
||
widget.yview_scroll(1, "units"); return "break"
|
||
widget.bind("<MouseWheel>", _mw)
|
||
widget.bind("<Button-4>", _mw_up)
|
||
widget.bind("<Button-5>", _mw_down)
|
||
|
||
|
||
def _watch_refresh_interval(self):
|
||
try:
|
||
val = float(self.refresh_var.get())
|
||
except Exception:
|
||
val = self._last_refresh_val
|
||
if val != self._last_refresh_val:
|
||
self._last_refresh_val = val
|
||
if self.poller and self.poller.is_alive():
|
||
try:
|
||
self.poller.refresh_interval = max(0.1, val)
|
||
self.status_lbl.configure(text=f"Running… (refresh {self.poller.refresh_interval}s)")
|
||
except Exception:
|
||
pass
|
||
self.after(2000, self._watch_refresh_interval)
|
||
|
||
def menu_run_once_dialog(self):
|
||
top = tk.Toplevel(self); top.title("Run Function Once"); top.geometry("420x180"); top.transient(self); top.grab_set()
|
||
ttk.Label(top, text="Function:").pack(pady=(10,2))
|
||
name = tk.StringVar(value=(self.functions_list[0] if self.functions_list else ""))
|
||
cmb = ttk.Combobox(top, values=self.functions_list, textvariable=name, width=44)
|
||
self._attach_search_filter_to_combobox(cmb, self.functions_list)
|
||
cmb.pack()
|
||
ttk.Label(top, text="Value:").pack(pady=(6,2))
|
||
val = tk.StringVar(value="1")
|
||
ttk.Entry(top, textvariable=val, width=16).pack()
|
||
def go():
|
||
fname = name.get().strip()
|
||
if not fname: return
|
||
status, body, _ = self.scheduler.run_once(fname, val.get())
|
||
messagebox.showinfo("Run Once", f"POST ?variable={fname}&value={val.get()}\nHTTP {status}\n{coerce_preview(body, 300)}")
|
||
top.destroy()
|
||
ttk.Button(top, text="Run", command=go).pack(pady=10)
|
||
|
||
def menu_schedule_dialog(self):
|
||
top = tk.Toplevel(self); top.title("Add Scheduled Function"); top.geometry("520x360"); top.transient(self); top.grab_set()
|
||
ttk.Label(top, text="Function:").pack(pady=(10,2))
|
||
name = tk.StringVar(value=(self.functions_list[0] if self.functions_list else ""))
|
||
cmb = ttk.Combobox(top, values=self.functions_list, textvariable=name, width=44)
|
||
self._attach_search_filter_to_combobox(cmb, self.functions_list)
|
||
cmb.pack()
|
||
# Mode: Fixed vs Expression
|
||
mode = tk.StringVar(value="expr")
|
||
frm = ttk.Frame(top); frm.pack(pady=(8,2))
|
||
ttk.Radiobutton(frm, text="Fixed value", variable=mode, value="fixed").pack(side=tk.LEFT, padx=6)
|
||
ttk.Radiobutton(frm, text="Expression", variable=mode, value="expr").pack(side=tk.LEFT, padx=6)
|
||
# Fixed value input
|
||
val = tk.StringVar(value="1")
|
||
fixed_row = ttk.Frame(top); fixed_row.pack(fill=tk.X, padx=10, pady=(4,2))
|
||
ttk.Label(fixed_row, text="Value:").pack(side=tk.LEFT)
|
||
val_entry = ttk.Entry(fixed_row, textvariable=val, width=16)
|
||
val_entry.pack(side=tk.LEFT, padx=6)
|
||
# Expression + sources
|
||
expr = tk.StringVar(value="x")
|
||
expr_row = ttk.Frame(top); expr_row.pack(fill=tk.X, padx=10, pady=(4,2))
|
||
ttk.Label(expr_row, text="Expression (x,y,z):").pack(side=tk.LEFT)
|
||
expr_entry = ttk.Entry(expr_row, textvariable=expr, width=46)
|
||
expr_entry.pack(side=tk.LEFT, padx=6)
|
||
# Sources row
|
||
src_row = ttk.Frame(top); src_row.pack(fill=tk.X, padx=10, pady=(4,2))
|
||
ttk.Label(src_row, text="x:").pack(side=tk.LEFT)
|
||
x_src = tk.StringVar(value="")
|
||
x_combo = ttk.Combobox(src_row, values=self.known_variables, textvariable=x_src, width=18)
|
||
self._attach_search_filter_to_combobox(x_combo, self.known_variables)
|
||
x_combo.pack(side=tk.LEFT, padx=4)
|
||
ttk.Label(src_row, text="y:").pack(side=tk.LEFT)
|
||
y_src = tk.StringVar(value="")
|
||
y_combo = ttk.Combobox(src_row, values=self.known_variables, textvariable=y_src, width=18)
|
||
self._attach_search_filter_to_combobox(y_combo, self.known_variables)
|
||
y_combo.pack(side=tk.LEFT, padx=4)
|
||
ttk.Label(src_row, text="z:").pack(side=tk.LEFT)
|
||
z_src = tk.StringVar(value="")
|
||
z_combo = ttk.Combobox(src_row, values=self.known_variables, textvariable=z_src, width=18)
|
||
self._attach_search_filter_to_combobox(z_combo, self.known_variables)
|
||
z_combo.pack(side=tk.LEFT, padx=4)
|
||
# Interval input
|
||
ttk.Label(top, text="Interval (seconds, can be < 1.0):").pack(pady=(6,2))
|
||
interval = tk.DoubleVar(value=1.0)
|
||
ttk.Entry(top, textvariable=interval, width=12).pack()
|
||
def update_mode(*_):
|
||
if mode.get() == "fixed":
|
||
val_entry.configure(state="normal")
|
||
expr_entry.configure(state="disabled")
|
||
x_combo.configure(state="disabled"); y_combo.configure(state="disabled"); z_combo.configure(state="disabled")
|
||
else:
|
||
val_entry.configure(state="disabled")
|
||
expr_entry.configure(state="normal")
|
||
x_combo.configure(state="normal"); y_combo.configure(state="normal"); z_combo.configure(state="normal")
|
||
mode.trace_add("write", update_mode); update_mode()
|
||
def go():
|
||
fname = name.get().strip()
|
||
if not fname: return
|
||
if mode.get() == "fixed":
|
||
task = ActionTask(name=fname, value=val.get(), interval_s=max(0.0, float(interval.get())))
|
||
else:
|
||
task = ActionTask(name=fname, value="", interval_s=max(0.0, float(interval.get())), expr=expr.get().strip() or "x", x_src=(x_src.get().strip() or None), y_src=(y_src.get().strip() or None), z_src=(z_src.get().strip() or None))
|
||
tid = self.scheduler.add_task(task)
|
||
self.refresh_actions_tree()
|
||
top.destroy()
|
||
ttk.Button(top, text="Add", command=go).pack(pady=10)
|
||
|
||
def save_config(self):
|
||
try:
|
||
from tkinter import filedialog
|
||
cfg = {
|
||
"host": self.host_var.get(),
|
||
"port": int(self.port_var.get()),
|
||
"refresh_interval": float(self.refresh_var.get()),
|
||
"variables_keys": self.variables_keys,
|
||
"vars": {k: self._serialize_varinfo(v) for k,v in self.vars.items() if k in self.variables_keys},
|
||
"scheduled_tasks": [self._serialize_task(t) for t in self.scheduler.list_tasks()],
|
||
}
|
||
path = filedialog.asksaveasfilename(defaultextension=".json", filetypes=[("JSON","*.json")], title="Save Configuration")
|
||
if not path: return
|
||
import json
|
||
with open(path, "w", encoding="utf-8") as f:
|
||
json.dump(cfg, f, indent=2)
|
||
messagebox.showinfo("Saved", f"Configuration saved to:\n{path}")
|
||
except Exception as e:
|
||
messagebox.showerror("Save failed", str(e))
|
||
|
||
def load_config(self):
|
||
try:
|
||
from tkinter import filedialog
|
||
path = filedialog.askopenfilename(filetypes=[("JSON","*.json")], title="Load Configuration")
|
||
if not path: return
|
||
import json
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
cfg = json.load(f)
|
||
self.host_var.set(cfg.get("host", self.host_var.get()))
|
||
self.port_var.set(cfg.get("port", self.port_var.get()))
|
||
self.refresh_var.set(cfg.get("refresh_interval", self.refresh_var.get()))
|
||
keys = cfg.get("variables_keys", [])
|
||
self.variables_keys = [k.lower() for k in keys]
|
||
new_vars = {}
|
||
for k, data in (cfg.get("vars") or {}).items():
|
||
vi = self._deserialize_varinfo(k, data)
|
||
new_vars[k.lower()] = vi
|
||
self.vars = new_vars
|
||
# replace scheduled tasks
|
||
for t in [t.task_id for t in self.scheduler.list_tasks()]:
|
||
self.scheduler.remove_task(t)
|
||
for td in cfg.get("scheduled_tasks", []):
|
||
self.scheduler.add_task(self._deserialize_task(td))
|
||
if self.poller and self.poller.is_alive():
|
||
self.poller.variables_keys = self.variables_keys[:]
|
||
self.refresh_tree()
|
||
self.refresh_actions_tree()
|
||
messagebox.showinfo("Loaded", f"Configuration loaded from:\n{path}")
|
||
except Exception as e:
|
||
messagebox.showerror("Load failed", str(e))
|
||
|
||
def _serialize_varinfo(self, vi: VarInfo):
|
||
t = vi.thresholds
|
||
return {
|
||
"display_name": vi.display_name,
|
||
"thresholds": {
|
||
"dead_low": t.dead_low, "low": t.low, "high": t.high, "extreme_high": t.extreme_high,
|
||
"alarm_dead_low": t.alarm_dead_low, "alarm_low": t.alarm_low, "alarm_high": t.alarm_high, "alarm_extreme_high": t.alarm_extreme_high,
|
||
"action_dead_low": t.action_dead_low, "value_dead_low": t.value_dead_low, "action_dead_low_interval": t.action_dead_low_interval,
|
||
"action_low": t.action_low, "value_low": t.value_low, "action_low_interval": t.action_low_interval,
|
||
"action_high": t.action_high, "value_high": t.value_high, "action_high_interval": t.action_high_interval,
|
||
"action_extreme_high": t.action_extreme_high, "value_extreme_high": t.value_extreme_high, "action_extreme_high_interval": t.action_extreme_high_interval,
|
||
"action_operating": t.action_operating, "value_operating": t.value_operating, "action_operating_interval": t.action_operating_interval,
|
||
"expr_dead_low": t.expr_dead_low, "expr_low": t.expr_low, "expr_operating": t.expr_operating, "expr_high": t.expr_high, "expr_extreme_high": t.expr_extreme_high,
|
||
"expr_target_dead_low": t.expr_target_dead_low, "expr_target_low": t.expr_target_low, "expr_target_operating": t.expr_target_operating, "expr_target_high": t.expr_target_high, "expr_target_extreme_high": t.expr_target_extreme_high,
|
||
# nowości:
|
||
"expr_operating_interval": getattr(t, "expr_operating_interval", 1.0),
|
||
"y_source": getattr(t, "y_source", None),
|
||
"z_source": getattr(t, "z_source", None),
|
||
},
|
||
}
|
||
def _deserialize_varinfo(self, key: str, data: dict) -> VarInfo:
|
||
name = data.get("display_name", key)
|
||
td = (data or {}).get("thresholds", {}) or {}
|
||
t = Thresholds(
|
||
dead_low=td.get("dead_low"), low=td.get("low"), high=td.get("high"), extreme_high=td.get("extreme_high"),
|
||
alarm_dead_low=bool(td.get("alarm_dead_low", True)), alarm_low=bool(td.get("alarm_low", False)),
|
||
alarm_high=bool(td.get("alarm_high", False)), alarm_extreme_high=bool(td.get("alarm_extreme_high", True)),
|
||
action_dead_low=td.get("action_dead_low"), value_dead_low=str(td.get("value_dead_low", "1")), action_dead_low_interval=float(td.get("action_dead_low_interval", 1.0)),
|
||
action_low=td.get("action_low"), value_low=str(td.get("value_low", "1")), action_low_interval=float(td.get("action_low_interval", 1.0)),
|
||
action_high=td.get("action_high"), value_high=str(td.get("value_high", "1")), action_high_interval=float(td.get("action_high_interval", 1.0)),
|
||
action_extreme_high=td.get("action_extreme_high"), value_extreme_high=str(td.get("value_extreme_high", "1")), action_extreme_high_interval=float(td.get("action_extreme_high_interval", 1.0)),
|
||
action_operating=td.get("action_operating"), value_operating=str(td.get("value_operating", "1")), action_operating_interval=float(td.get("action_operating_interval", 1.0)),
|
||
expr_dead_low=td.get("expr_dead_low"), expr_low=td.get("expr_low"), expr_operating=td.get("expr_operating"),
|
||
expr_high=td.get("expr_high"), expr_extreme_high=td.get("expr_extreme_high"),
|
||
expr_target_dead_low=td.get("expr_target_dead_low"), expr_target_low=td.get("expr_target_low"),
|
||
expr_target_operating=td.get("expr_target_operating"), expr_target_high=td.get("expr_target_high"), expr_target_extreme_high=td.get("expr_target_extreme_high"),
|
||
# nowości (wstecznie opcjonalne):
|
||
expr_operating_interval=float(td.get("expr_operating_interval", 1.0)),
|
||
y_source=td.get("y_source"), z_source=td.get("z_source"),
|
||
)
|
||
return VarInfo(key=key.lower(), display_name=name, thresholds=t)
|
||
|
||
def _serialize_task(self, t: ActionTask):
|
||
return {"name": t.name, "value": t.value, "interval_s": t.interval_s, "enabled": t.enabled, "expr": t.expr, "x_src": t.x_src, "y_src": t.y_src, "z_src": t.z_src}
|
||
|
||
def _deserialize_task(self, d: dict) -> ActionTask:
|
||
return ActionTask(name=d.get("name",""), value=d.get("value","1"), interval_s=float(d.get("interval_s", 1.0)), enabled=d.get("enabled", True), expr=d.get("expr"), x_src=d.get("x_src"), y_src=d.get("y_src"), z_src=d.get("z_src"))
|
||
def on_close(self) -> None:
|
||
try:
|
||
if self.poller and self.poller.is_alive():
|
||
self.stop_event.set()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
self.scheduler.stop()
|
||
except Exception:
|
||
pass
|
||
self.destroy()
|
||
|
||
# --- Utils ---
|
||
def parse_first_float(value: str) -> Optional[float]:
|
||
if value is None:
|
||
return None
|
||
m = re.search(r"[-+]?\d+(?:\.\d+)?", str(value).replace(",", "."))
|
||
if m:
|
||
try:
|
||
return float(m.group(0))
|
||
except Exception:
|
||
return None
|
||
return None
|
||
|
||
def eval_user_expression(expr: str, x: float, y: float | None = None, z: float | None = None):
|
||
"""Evaluate user expression/snippet with x available.
|
||
Allowed: math.*, min, max, abs, round, int, float, clamp (custom).
|
||
Returns the computed result.
|
||
"""
|
||
def clamp(v, lo, hi):
|
||
return max(lo, min(hi, v))
|
||
safe_globals = {"__builtins__": {}, "math": math, "min": min, "max": max, "abs": abs, "round": round, "int": int, "float": float, "clamp": clamp}
|
||
safe_locals = {"x": x, "y": y, "z": z}
|
||
if "\n" in expr or ";" in expr:
|
||
code = compile(expr, "<expr>", "exec")
|
||
exec(code, safe_globals, safe_locals)
|
||
if "result" not in safe_locals:
|
||
raise ValueError("Snippet must assign to 'result', e.g., result = x * 1.1")
|
||
return safe_locals["result"]
|
||
else:
|
||
code = compile(expr, "<expr>", "eval")
|
||
return eval(code, safe_globals, safe_locals)
|
||
|
||
def main() -> None:
|
||
app = App()
|
||
app.mainloop()
|
||
|
||
if __name__ == "__main__":
|
||
main() |