"""CHEM-011 BINDER FD 56 (FD056-230V, 9010-0303) drying and heating chamber with forced convection: process runtime. Device (BINDER Data Sheet Model FD 56, 27.04.2022; operating manual BD/BF/ED/FD/FED E3.1 12/2017): 60 l interior (400 x 440 x 345 mm, steam space 67 l), ambient + 10 C to 300 C, fluctuation +-0.3 K and variation +-1.7 K at 150 C, 15 min to 150 C, 4 min recovery after the door was open 30 s, 80 air changes per hour at 100 C, 1.1 kW, 290 Wh/h at 150 C; R4 controller in the triangular panel on the door (up, down, OK, back, standby keys; set-point in 1 C steps; fixed fan speed), electromechanical exhaust air flap (CLOS, 1, 2, 3, OPEn in 15 deg steps), class 2 safety controller (temperature limiter 10-300 C: heating off until manual reset, '!TLim'), class 1 overtemperature protective device (330 C, reset below 230 C after disconnecting the mains >= 10 s), timer 'Delayed Off' (0-9 d, 0-23 h, 0-59 min; fan on or off afterwards), ramp function, USB data recording; heating and fan stop while the door is open; 2 (max. 4) chrome racks of 30 kg, 70 kg in total; 560 x 625 x 565 mm. Process model (fixed 0.1 s grid; standby or no mains with everything at ambient and no wet sample is skipped exactly; SI units): * Four nodes: heater element, chamber air (+ fan duct), inner liner with racks, insulation and outer shell: C_h dT_h/dt = P_heat - G_ha (T_h - T_a) - G_hl (T_h - T_l); C_a dT_a/dt = G_ha (T_h - T_a) + P_fan - G_la (T_a - T_l) - m_dot c_p (T_a - T_amb) - sum Q_sample C_l dT_l/dt = G_la (T_a - T_l) + G_hl (T_h - T_l) - G_ls (T_l - T_s) - G_door (T_l - T_amb); C_s dT_s/dt = G_ls (T_l - T_s) - G_sa (T_s - T_amb) G_ha, G_la with / without fan; m_dot from the air change of the flap position (80 /h fully open, datasheet) or the door-open exchange. G_ls, C_l and the door-open exchange are calibrated to the datasheet (290 W at 150 C, 15 min to 150 C, 4 min recovery). * Controller: Pt100 (first-order lag + noise) -> PID on the (ramp-limited) set-point -> heater duty through a solid-state relay period; the safety controller (class 2) latches the heating off above its limit; the class 1 device cuts above 330 C. * Samples on the racks: labware (load_templates.json materials) + dry solid + a liquid (CHEM-008 liquid library): C dT/dt = h A (T_local - T) - m_evap h_vap; m_evap = k_m A_open (p_vap(T) - p_partial) M / (R T) x min(1, X / X_crit) (constant, then falling rate); boiling above T_b(p); the vapour is held in the chamber air and vented with the air change (its total partial pressure never exceeds the ambient pressure - the excess is displaced through the exhaust; vapour above saturation at the air temperature condenses on the liner, its latent heat back to the air, the condensate drained and not re-evaporated); the local air temperature carries the documented +-1.7 K spatial field. * Ledgers: electric heater + fan energy + condensation heat + sample enthalpy in = node and sample enthalpy + shell and door losses + vented air + latent heat + sample enthalpy out; every liquid's mass: placed = on samples + evaporated + boiled + removed; vapour: evaporated + boiled = in the chamber + vented + condensed.""" import copy import json import math import re from pathlib import Path PROTOCOL_VERSION = "1.0.0" ASSET_TYPE_ID = "instrument.binder_fd056" CATALOG_ID = "CHEM-011" ROOT = Path(__file__).resolve().parents[2] ASSET_DIR = ROOT / 'assets/expansion_batch05/t4_measure/binder_fd056' LIBS = {'instrument': 'instrument_model.json', 'loads': 'load_templates.json'} C0 = 273.15 DT = 0.1 R_GAS = 8.314462618 M_AIR = 0.028965 CP_AIR = 1006.0 MAX_EVENTS_LOG = 3000 MAX_USB_ROWS = 200000 class ActionRejected(ValueError): """A capability call refused with a declared error code (no state change).""" def _step_round(x, step): """Round half up to a multiple of step (the arrow keys never round half to even).""" return math.floor(x / step + 0.5 + 1e-12) * step _LIBC = {} def _lib(name): if name not in _LIBC: _LIBC[name] = json.loads((ASSET_DIR / LIBS[name]).read_text()) return _LIBC[name] def instrument(): return _lib('instrument') DOC = {k: v['value'] for k, v in instrument()['documented'].items()} ENG = {k: v['value'] for k, v in instrument()['engineering'].items()} ENG_NOTE = {k: v['engineering_note_zh'] for k, v in instrument()['engineering'].items()} ENG_UNIT = {k: v['unit'] for k, v in instrument()['engineering'].items()} MAT = _lib('loads')['materials'] LIQ = _lib('loads')['liquids'] LIQ_IDS = sorted(LIQ) WARES = ENG['ware_catalogue'] V_AIR = DOC['steam_space_m3'] T_MAX_SET = C0 + DOC['temperature_max_c'] SAFE_RANGE_K = (C0 + DOC['safety_range_c'][0], C0 + DOC['safety_range_c'][1]) CLASS1 = (C0 + DOC['overtemp_class1_text']['cut_off_c'], C0 + DOC['overtemp_class1_text']['reset_c']) LEVELS = (1, 2, 3, 4) POSITIONS = ('front_left', 'front_right', 'rear_left', 'rear_right') FLAP_TEXT = {0: 'CLOS', 1: '1', 2: '2', 3: '3', 4: 'OPEn'} _M64 = (1 << 64) - 1 def _mix64(x): x = (x + 0x9E3779B97F4A7C15) & _M64 x = ((x ^ (x >> 30)) * 0xBF58476D1CE4E5B9) & _M64 x = ((x ^ (x >> 27)) * 0x94D049BB133111EB) & _M64 return x ^ (x >> 31) def _uni(seed, k, ch): return ((_mix64(_mix64(_mix64(seed & _M64) ^ (k & _M64)) ^ ch) >> 11) + 0.5) / 9007199254740992.0 def _gauss(seed, k, ch): u1, u2 = _uni(seed, k, 2 * ch), _uni(seed, k, 2 * ch + 1) return math.sqrt(-2.0 * math.log(u1)) * math.cos(2 * math.pi * u2) # ---------------------------------------------------------------- liquid properties (CHEM-008 liquid template library) def p_vap(sid, t_k): """Vapour pressure (Pa): the template's Antoine fit or its Clausius-Clapeyron runtime model (see the CHEM-008 library).""" v = LIQ[sid]['vapour_pressure'] v = v.get('runtime_model', v) if v['kind'] == 'antoine': return 1e5 * 10.0 ** (v['A'] - v['B_k'] / (t_k + v['C_k'])) return v['p_ref_pa'] * math.exp(-v['dh_vap_j_mol'] / R_GAS * (1.0 / t_k - 1.0 / v['t_ref_k'])) def boiling_k(sid, pressure_pa): s = LIQ[sid] return 1.0 / (1.0 / s['boiling_point']['value'] - R_GAS / s['enthalpy_vaporization']['molar_j_mol'] * math.log(pressure_pa / 101325.0)) def air_density(t_k, p_pa): return p_pa * M_AIR / (R_GAS * t_k) # ---------------------------------------------------------------- schema helpers def number(unit='1', lo=None, hi=None): s = {'type': 'number', 'x-unit': unit} if lo is not None: s['minimum'] = lo if hi is not None: s['maximum'] = hi return s def obj(properties, optional=()): return dict(type='object', properties=properties, required=[k for k in properties if k not in optional], additionalProperties=False) def nullable(s): return {'anyOf': [s, {'type': 'null'}]} def array(s, minimum=0, maximum=4096): return dict(type='array', items=s, minItems=minimum, maxItems=maximum) def enum(items): return {'type': 'string', 'enum': list(items)} def integer(lo, hi): return {'type': 'integer', 'x-unit': '1', 'minimum': lo, 'maximum': hi} BOOL = {'type': 'boolean'} TEXT = {'type': 'string', 'maxLength': 80} SAMPLE_ID = {'type': 'string', 'minLength': 1, 'maxLength': 32, 'pattern': r'[A-Za-z0-9_\-]+'} FREE_OBJ = dict(type='object') def validate(s, v): if 'anyOf' in s: for o in s['anyOf']: try: validate(o, v) return except ActionRejected: pass raise ActionRejected('INVALID_ARGUMENT') k = s.get('type') if k in ('number', 'integer'): if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v) or (k == 'integer' and not float(v).is_integer()): raise ActionRejected('INVALID_ARGUMENT') if not s.get('minimum', -math.inf) <= v <= s.get('maximum', math.inf): raise ActionRejected('INVALID_ARGUMENT') elif k == 'object': if not isinstance(v, dict): raise ActionRejected('INVALID_ARGUMENT') if 'properties' in s: req = set(s.get('required', s['properties'])) if not req <= set(v) or not set(v) <= set(s['properties']): raise ActionRejected('INVALID_ARGUMENT') for key, value in v.items(): validate(s['properties'][key], value) elif k == 'array': if not isinstance(v, list) or not s.get('minItems', 0) <= len(v) <= s.get('maxItems', math.inf): raise ActionRejected('INVALID_ARGUMENT') for x in v: validate(s['items'], x) elif k == 'boolean' and type(v) is not bool: raise ActionRejected('INVALID_ARGUMENT') elif k == 'string': if not isinstance(v, str) or len(v) > s.get('maxLength', 10 ** 6) or len(v) < s.get('minLength', 0): raise ActionRejected('INVALID_ARGUMENT') if 'pattern' in s and not re.fullmatch(s['pattern'], v): raise ActionRejected('INVALID_ARGUMENT') if 'enum' in s and v not in s['enum']: raise ActionRejected('INVALID_ARGUMENT') # ---------------------------------------------------------------- capabilities CAPS = {} def cap(k, s, o, e, c, meaning, visibility='agent', kind='device_command'): CAPS[k] = dict(input_schema=s, output_schema=o, example_arguments=e, component_ids=c, function_zh=meaning, visibility=visibility, kind=kind) TEMP = number('K', C0, T_MAX_SET) PLANT_EXAMPLE = dict(ambient_k=295.15, pressure_pa=101325.0, mains_v=230.0, noise_seed=1) PLANT = obj(dict(ambient_k=number('K', C0 + 18.0, C0 + 40.0), pressure_pa=number('Pa', 70000.0, 110000.0), mains_v=number('V', 200.0, 253.0), noise_seed=integer(0, 2 ** 31 - 1), relative_humidity=number('1', 0.0, 1.0)), optional=('relative_humidity',)) SAMPLE = obj(dict(sample_id=SAMPLE_ID, level=integer(1, 4), position=enum(POSITIONS), ware=enum(sorted(WARES)), dry_mass_kg=number('kg', 0.0, 30.0), dry_cp_j_kgk=number('J/(kg K)', 100.0, 5000.0), dry_density_kg_m3=number('kg/m3', 200.0, 22000.0), liquid_id=nullable(enum(LIQ_IDS)), liquid_mass_kg=number('kg', 0.0, 5.0), initial_k=number('K', 250.0, 600.0)), optional=('dry_cp_j_kgk', 'dry_density_kg_m3', 'liquid_id', 'liquid_mass_kg', 'initial_k')) SAMPLE_EXAMPLE = dict(sample_id='s1', level=1, position='front_left', ware='weighing_bottle_50x30', dry_mass_kg=0.005, liquid_id='water', liquid_mass_kg=0.002) FAULTS = ['mains_outage', 'heater_open', 'ssr_stuck_on', 'sensor_rupture', 'fan_failure', 'safety_controller_failure'] cap('plant.configure', PLANT, obj(dict(configured=BOOL)), PLANT_EXAMPLE, ['housing'], '声明环境：室温（18–40 °C）、大气压、电源电压、相对湿度（默认0.5）与噪声种子（之后可改环境，种子不可改）', 'evaluator', 'configuration') cap('power.set', obj(dict(on=BOOL)), obj(dict(on=BOOL)), dict(on=True), ['btn_standby'], '待机键（按住约3 s）：开（正常显示、控温与风机）或待机') cap('power.toggle', obj({}), obj(dict(on=BOOL)), {}, ['btn_standby'], '按住待机键约3 s：切换开/待机') cap('door.set', obj(dict(angle_rad=number('rad', 0.0, ENG['door_max_rad']))), obj(dict(angle_rad=number('rad'), open=BOOL)), dict(angle_rad=1.57), ['door'], '开关门（门把手；开角0–103.5°；开门时加热与风机停止）', 'agent', 'robot_skill') cap('temperature.set', obj(dict(temperature_k=TEMP)), obj(dict(temperature_k=TEMP)), dict(temperature_k=C0 + 105.0), ['panel'], '设定温度（设定菜单：方向键+OK；1 °C步进，0–300 °C；低于室温+10 °C的设定达不到——不能制冷）', 'agent', 'configuration') cap('temperature.step', obj(dict(delta_k=number('K', -10.0, 10.0))), obj(dict(temperature_k=TEMP)), dict(delta_k=1.0), ['btn_up', 'btn_down'], '方向键：设定温度加/减（整数K；场景中上键+1 K、下键−1 K）') cap('safety.set_limit', obj(dict(limit_k=number('K', *SAFE_RANGE_K))), obj(dict(limit_k=number('K'))), dict(limit_k=C0 + 110.0), ['panel'], '2级安全控制器设定（10–300 °C，1 °C；宜比温度设定高2–5 °C；超过时完全关闭加热直到手动复位）', 'agent', 'configuration') cap('alarm.acknowledge', obj({}), obj(dict(alarm=nullable(TEXT), timer=FREE_OBJ)), {}, ['btn_ok'], 'OK键：复位已冷却到安全设定以下的2级报警并恢复控温；定时结束后关闭定时功能（恢复加热）') cap('flap.set', obj(dict(position=integer(0, 4))), obj(dict(position=integer(0, 4), text=TEXT)), dict(position=2), ['flap_actuator'], '排气风门开度（0=CLOS、1、2、3、4=OPEn，15°步进；开度越大换气越多，全开时均匀性变差）', 'agent', 'configuration') cap('timer.set', obj(dict(days=integer(0, 9), hours=integer(0, 23), minutes=integer(0, 59), fan_after=enum(['on', 'off'])), optional=('fan_after',)), obj(dict(timer=FREE_OBJ)), dict(days=0, hours=2, minutes=0, fan_after='on'), ['panel'], '定时“延时关闭”：立即开始倒计时，结束时关加热，风机按选择开（100 %）或关；全部为0时结束定时', 'agent', 'configuration') cap('ramp.set', obj(dict(gradient_k_min=integer(0, 10), target_k=TEMP)), obj(dict(ramp=FREE_OBJ)), dict(gradient_k_min=2, target_k=C0 + 150.0), ['panel'], '斜坡：梯度（°C/min，0关闭）与目标设定；目标高于实际温度时有效设定按梯度上升', 'agent', 'configuration') cap('unit.set', obj(dict(unit=enum(['C', 'F']))), obj(dict(unit=enum(['C', 'F']))), dict(unit='C'), ['panel'], '温度单位°C/°F（只影响显示；接口一律SI）', 'agent', 'configuration') cap('display.cycle', obj({}), obj(dict(page=TEXT)), {}, ['btn_back'], '返回键：文字行在设定、风门、安全控制器、定时、斜坡、USB之间切换（菜单导航的抽象）') cap('usb.set_stick', obj(dict(inserted=BOOL)), obj(dict(inserted=BOOL)), dict(inserted=True), ['usb_port'], '在三角面板USB口插拔U盘', 'agent', 'robot_skill') cap('usb.record', obj(dict(on=BOOL, interval_min=integer(1, 60)), optional=('interval_min',)), obj(dict(usb=FREE_OBJ)), dict(on=True, interval_min=1), ['usb_port'], 'USB数据记录开始/停止（记录间隔1–60 min）：定时、实际温度、设定、风机、风门、安全控制器、加热比例', 'agent', 'configuration') cap('usb.read', obj(dict(since_s=number('s', 0.0)), optional=('since_s',)), obj(dict(rows=array(FREE_OBJ, 0, MAX_USB_ROWS), header=array(TEXT, 0, 16))), dict(since_s=0.0), ['usb_port'], '读出U盘上的CSV记录（运行记录）', 'agent', 'query') cap('rack.set', obj(dict(level=integer(1, 4), present=BOOL)), obj(dict(racks=array(integer(1, 4), 0, 4))), dict(level=2, present=True), ['liner'], '放入或取出搁架（层1–4；标准2层在1、3层；须开门；取出须先拿走其上的样品）', 'agent', 'robot_skill') cap('sample.place', SAMPLE, obj(dict(sample=FREE_OBJ)), SAMPLE_EXAMPLE, ['liner'], '把器皿（材料目录）连同干固体与湿液体（液体模板库）放到某层搁架的某个位置（须开门；搁架30 kg、总负载70 kg）', 'agent', 'robot_skill') cap('sample.remove', obj(dict(sample_id=SAMPLE_ID)), obj(dict(sample=FREE_OBJ)), dict(sample_id='s1'), ['liner'], '取出样品（须开门）：返回器皿与样品的总质量、干固体与剩余液体质量和温度（“干燥样品”输出，称量在天平上）', 'agent', 'robot_skill') cap('events.read', obj(dict(since_s=number('s', 0.0)), optional=('since_s',)), obj(dict(events=array(FREE_OBJ), dropped=integer(0, 10 ** 9))), dict(since_s=0.0), ['housing'], '事件与报警记录', 'agent', 'query') cap('truth.inspect', obj({}), obj(dict(process=FREE_OBJ, faults=array(TEXT, 0, 16))), {}, ['housing'], '评测者：各节点真实温度、换气、样品温度与含湿量、腔内蒸气', 'evaluator', 'query') cap('ledger.read', obj({}), obj(dict(ledger=FREE_OBJ)), {}, ['housing'], '评测者：能量与液体质量守恒账', 'evaluator', 'query') cap('fault.inject', obj(dict(fault=enum(FAULTS), active=BOOL)), obj(dict(faults=array(TEXT, 0, 16))), dict(fault='ssr_stuck_on', active=True), ['housing'], '评测者：注入或清除故障（停电、加热器断路、固态继电器常通、Pt100断线、风机故障、安全控制器失效）', 'evaluator', 'simulation') cap('sim.step', obj(dict(dt_s=number('s', 0.0, 30 * 86400.0))), obj(dict(time_s=number('s'))), dict(dt_s=10.0), ['housing'], '推进宿主时钟', 'evaluator', 'simulation') UNSUPPORTED = { 'fan.set_speed': '风速设定：FD为固定风速（手册：BF、FED才可设风速）。', 'timer.delayed_on': '定时“延时开启”：只有BF、FED（手册8.1）。', 'timer.temperature_dependent_off': '定时“温度相关延时关闭”：只有BF、FED（手册8.1）。', 'object_temperature.read': '物体温度显示（附加Pt100）：选件，本配置没有。', 'analog_output.read': '4–20 mA模拟输出：选件，本配置没有。', 'interior_light.set': '内部照明：选件，本配置没有。', 'inert_gas.connect': '惰性气体接口：选件（气密型），本配置没有。', 'network.connect': '以太网接口（APT-COM）：选件，本配置没有。', } for _k, _v in UNSUPPORTED.items(): cap(_k, obj({}), obj({}), {}, ['housing'], _v) # ---------------------------------------------------------------- state slots SLOTS = {} def slot(k, schema, unit, origin, component, meaning, visibility='agent'): SLOTS[k] = dict(schema=schema, unit=unit, origin=origin, component=component, meaning=meaning, visibility=visibility) slot('clock.time_s', number('s'), 's', 'derived', 'housing', '仿真时钟（宿主时钟）') slot('plant.configured', BOOL, '1', 'setpoint', 'housing', '环境是否已声明') slot('power.on', BOOL, '1', 'setpoint', 'btn_standby', '控制器开（非待机）') slot('door.angle_rad', number('rad', 0.0, ENG['door_max_rad']), 'rad', 'setpoint', 'door', '门开角（0关；门关节=该角）') slot('door.open', BOOL, '1', 'derived', 'door', '门开关：开角大于门开关阈值即为开门（加热与风机停）') slot('temperature.set_k', TEMP, 'K', 'setpoint', 'panel', '温度设定（斜坡运行时为目标；有效设定见ramp.state）') slot('safety.limit_k', number('K'), 'K', 'setpoint', 'panel', '2级安全控制器设定') slot('flap.position', integer(0, 4), '1', 'setpoint', 'flap_actuator', '排气风门开度（0=CLOS…4=OPEn）') slot('flap.angle_rad', number('rad', 0.0, math.radians(60.0)), 'rad', 'derived', 'flap_actuator', '风门执行器转角=开度×15°（后部风门执行器关节）') slot('timer.state', FREE_OBJ, '1', 'derived', 'panel', '定时“延时关闭”：是否设定、运行、结束、剩余时间、结束后风机') slot('ramp.state', FREE_OBJ, '1', 'derived', 'panel', '斜坡：梯度、目标、有效设定、是否运行') slot('unit', enum(['C', 'F']), '1', 'setpoint', 'panel', '显示温度单位') slot('usb.state', FREE_OBJ, '1', 'setpoint', 'usb_port', 'U盘是否插入、是否记录、间隔、已记行数') slot('racks.levels', array(integer(1, 4), 0, 4), '1', 'setpoint', 'liner', '搁架所在层') slot('samples.placed', array(FREE_OBJ, 0, 16), '1', 'setpoint', 'liner', '腔内样品：编号、层、位置、器皿（运行层不给出温度与质量——须取出称量）') slot('fan.running', BOOL, '1', 'derived', 'fan_cover', '风机是否运转（能听到）') slot('alarm.state', nullable(enum(['limit_active', 'limit_latched', 'overtemperature'])), '1', 'derived', 'panel', '报警：2级限温报警（仍高于安全设定/已降下待复位）或1级过温保护') slot('display.temperature', nullable(number('1')), '1', 'sensor', 'display', '大数字：实际温度（°C或°F，1°；Pt100断线显示1999；待机熄灭）') slot('display.text', TEXT, '1', 'derived', 'display', '文字行（七段字形）：设定“SP 150”、风门“FL CLOS”、安全“SAFE 160”、定时“t dhhmm”、斜坡、报警“ALAr tLI”等') for _k, _zh in (('heating', '加热图标'), ('timer', '定时图标'), ('alarm', '安全控制器报警图标'), ('standby', '待机图标')): slot(f'indicator.{_k}', BOOL, '1', 'derived', {'heating': 'icon_heating', 'timer': 'icon_timer', 'alarm': 'icon_alarm', 'standby': 'icon_standby'}[_k], _zh + '是否点亮') slot('truth.process', FREE_OBJ, '1', 'process_truth', 'liner', '加热器、空气、内胆、外壳真实温度，换气，加热功率，样品温度与含湿量，腔内蒸气', 'evaluator') slot('truth.faults', array(TEXT, 0, 16), '1', 'process_truth', 'housing', '已注入的故障', 'evaluator') SCENE_MIRRORED = {'door.angle_rad', 'flap.angle_rad', 'display.temperature', 'display.text', 'indicator.heating', 'indicator.timer', 'indicator.alarm', 'indicator.standby'} # ---------------------------------------------------------------- runtime class BinderFd056Runtime: def __init__(self, instance_id='binder_fd056_01'): self.instance_id = instance_id self.t = 0.0 self.t_grid = 0.0 self.tick = 0 self.plant = None self.seed = 0 self.on = False # starts in standby self.door = 0.0 self.set_k = C0 + 25.0 self.safe_k = SAFE_RANGE_K[1] # factory setting unknown: the maximum (assumption) self.flap = 0 self.unit = 'C' self.page = 'setp' self.timer = dict(set_s=0.0, remaining_s=0.0, running=False, expired=False, fan_after='on') self.ramp = dict(gradient=0, target_k=None, effective_k=None, active=False) self.usb = dict(inserted=False, recording=False, interval_s=60.0, next_s=None, rows=[]) self.racks = {1, 3} self.samples = {} self.alarm2 = None # None / 'active' / 'latched' self.class1 = False self.class1_reset_armed = False self.outage_since = None self.Th = self.Ta = self.Tl = self.Ts = self.Tsens = None self.vapour = {} # liquid id -> vapour mass in the chamber air (kg) self.ctrl = dict(i=0.0, e_prev=None, d=0.0, duty=0.0, heater_w=0.0) self.faults = set() self.events, self.events_dropped = [], 0 self.revision = 0 self.led = None self._principals, self._requests, self._caller = {}, {}, None # ---- sessions @property def time_s(self): return self.t def register_principal(self, name, visibility): if visibility not in ('agent', 'evaluator', 'debug'): raise ActionRejected('INVALID_ARGUMENT') self._principals[name] = visibility def session(self, name): if name not in self._principals: raise ActionRejected('ACCESS_DENIED') return BinderFd056Session(self, name) def _event(self, kind, code, message): self.events.append(dict(time_s=round(self.t, 6), kind=kind, code=code, message_zh=message)) if len(self.events) > MAX_EVENTS_LOG: self.events_dropped += len(self.events) - MAX_EVENTS_LOG del self.events[:-MAX_EVENTS_LOG] def _need_plant(self): if self.plant is None: raise ActionRejected('PLANT_REQUIRED') def _mains(self): return self.plant is not None and 'mains_outage' not in self.faults def _active(self): return self.on and self._mains() def _need_active(self): self._need_plant() if not self._mains(): raise ActionRejected('NO_MAINS') if not self.on: raise ActionRejected('STANDBY') def _door_open(self): return self.door > ENG['door_switch_rad'] def _need_door_open(self): if not self._door_open(): raise ActionRejected('DOOR_CLOSED') def _fan_on(self): if not self._active() or self._door_open() or 'fan_failure' in self.faults: return False return not (self.timer['expired'] and self.timer['fan_after'] == 'off') def _effective_set(self): return self.ramp['effective_k'] if self.ramp['active'] else self.set_k # ---- samples def _sample_cap(self, s): w = WARES[s['ware']] cp_l = LIQ[s['liquid_id']]['heat_capacity']['value'] if s['liquid_id'] else 0.0 return w['mass_kg'] * MAT[w['material']]['heat_capacity']['value'] + s['dry_mass_kg'] * s['dry_cp'] + s['liquid_kg'] * cp_l def _sample_mass(self, s): return WARES[s['ware']]['mass_kg'] + s['dry_mass_kg'] + s['liquid_kg'] def _rack_load(self, level): return sum(self._sample_mass(s) for s in self.samples.values() if s['level'] == level) def _offset(self, level, position): """Local air temperature offset (K) at a rack position: the documented +-1.7 K at 150 C, scaled with the over-temperature.""" ta = self.plant['ambient_k'] f = ENG['uniformity_shape'][level - 1][POSITIONS.index(position)] g = DOC['temperature_variation_150_k'] * (self.Ta - ta) / (C0 + 150.0 - (C0 + 22.0)) if self.flap == 4: g *= ENG['flap_open_uniformity_factor'] if not self._fan_on(): g *= ENG['nofan_uniformity_factor'] return f * g # ---- capabilities def invoke(self, capability_id, **args): if capability_id in UNSUPPORTED: raise ActionRejected('UNSUPPORTED') fn = getattr(self, '_cmd_' + capability_id.replace('.', '_')) out = fn(**args) if capability_id not in ('events.read', 'truth.inspect', 'ledger.read', 'usb.read'): self.revision += 1 return out def _cmd_plant_configure(self, ambient_k, pressure_pa, mains_v, noise_seed, relative_humidity=None): if self.plant is not None and noise_seed != self.seed: raise ActionRejected('SEED_FIXED') rh = ENG['ambient_rh_default'] if relative_humidity is None else float(relative_humidity) first = self.plant is None if not first: for s in self.samples.values(): if s['liquid_id'] and s['liquid_kg'] > 0.0 and (LIQ[s['liquid_id']].get('melting_point_k') or 0.0) >= ambient_k: raise ActionRejected('NOT_LIQUID') if not first and ambient_k != self.plant['ambient_k']: # enthalpies are counted relative to ambient: book the change of reference d = ambient_k - self.plant['ambient_k'] self.led['e_reconfigure_j'] += -(self._node_cap() + sum(self._sample_cap(s) for s in self.samples.values())) * d self.plant = dict(ambient_k=ambient_k, pressure_pa=pressure_pa, mains_v=mains_v, relative_humidity=rh) self.seed = noise_seed if first: self.Th = self.Ta = self.Tl = self.Ts = self.Tsens = ambient_k self.led = dict(e_heater_j=0.0, e_fan_j=0.0, e_shell_loss_j=0.0, e_door_loss_j=0.0, e_vent_j=0.0, e_latent_j=0.0, e_samples_in_j=0.0, e_samples_out_j=0.0, e_ambient_reset_j=0.0, e_reconfigure_j=0.0, m_placed_kg=0.0, m_evaporated_kg=0.0, m_boiled_kg=0.0, m_removed_kg=0.0, m_vented_kg=0.0, m_condensed_kg=0.0, e_condensation_j=0.0, e_electric_total_j=0.0) self._event('system', 'PLANT_CONFIGURED', '环境已声明（插上电源）') return dict(configured=True) def _node_cap(self): return ENG['heater_heat_capacity_j_k'] + ENG['air_heat_capacity_j_k'] + ENG['liner_heat_capacity_j_k'] + ENG['shell_heat_capacity_j_k'] def _cmd_power_set(self, on): self._need_plant() if not self._mains(): raise ActionRejected('NO_MAINS') if on != self.on: self.on = on self.ctrl.update(i=0.0, e_prev=None, d=0.0) self._event('operation', 'STANDBY_OFF' if on else 'STANDBY_ON', '退出待机（正常显示）' if on else '进入待机') return dict(on=self.on) def _cmd_power_toggle(self): return self._cmd_power_set(not self.on) def _cmd_door_set(self, angle_rad): self._need_plant() was = self._door_open() self.door = float(angle_rad) if was != self._door_open(): self._event('operation', 'DOOR_OPEN' if self._door_open() else 'DOOR_CLOSED', '开门（加热与风机停）' if self._door_open() else '关门') if self._door_open(): self.ctrl.update(duty=0.0, heater_w=0.0, i=0.0, e_prev=None, d=0.0) # the door switch cuts heater and fan immediately (manual 5.1) return dict(angle_rad=self.door, open=self._door_open()) def _cmd_temperature_set(self, temperature_k): self._need_active() t = C0 + _step_round(temperature_k - C0, 1.0) self.set_k = min(max(t, C0), T_MAX_SET) self.ramp.update(active=False, effective_k=None, gradient=0, target_k=None) self.ctrl.update(i=0.0) return dict(temperature_k=self.set_k) def _cmd_temperature_step(self, delta_k): self._need_active() return self._cmd_temperature_set(min(max(self.set_k + _step_round(delta_k, 1.0), C0), T_MAX_SET)) def _cmd_safety_set_limit(self, limit_k): self._need_active() self.safe_k = C0 + _step_round(limit_k - C0, 1.0) self._event('operation', 'SAFETY_SET', f'安全控制器设定{self.safe_k - C0:.0f} °C') return dict(limit_k=self.safe_k) def _cmd_alarm_acknowledge(self): self._need_active() if self.alarm2 == 'latched': self.alarm2 = None self.ctrl.update(i=0.0, e_prev=None, d=0.0) self._event('operation', 'ALARM_RESET', '复位2级安全控制器报警，恢复控温') if self.timer['expired']: self.timer.update(set_s=0.0, remaining_s=0.0, running=False, expired=False) self._event('operation', 'TIMER_OFF', '关闭已结束的定时功能，恢复加热') return dict(alarm=self._alarm_state(), timer=self._timer_view()) def _cmd_flap_set(self, position): self._need_active() self.flap = int(position) return dict(position=self.flap, text=FLAP_TEXT[self.flap]) def _cmd_timer_set(self, days, hours, minutes, fan_after=None): self._need_active() total = days * 86400.0 + hours * 3600.0 + minutes * 60.0 if total <= 0.0: self.timer.update(set_s=0.0, remaining_s=0.0, running=False, expired=False) self._event('operation', 'TIMER_OFF', '定时结束（全部设为0）') else: self.timer = dict(set_s=total, remaining_s=total, running=True, expired=False, fan_after=fan_after or self.timer['fan_after']) self._event('operation', 'TIMER_SET', f'延时关闭定时{days} d {hours} h {minutes} min') return dict(timer=self._timer_view()) def _timer_view(self): tm = self.timer return dict(set=tm['set_s'] > 0.0, running=tm['running'], expired=tm['expired'], remaining_s=tm['remaining_s'], set_s=tm['set_s'], fan_after=tm['fan_after']) def _cmd_ramp_set(self, gradient_k_min, target_k): self._need_active() target = C0 + _step_round(target_k - C0, 1.0) if gradient_k_min == 0 or target <= self.Tsens: # off, or the target is not above the actual value: set directly self.set_k = target self.ramp = dict(gradient=int(gradient_k_min), target_k=target if gradient_k_min else None, effective_k=None, active=False) else: self.ramp = dict(gradient=int(gradient_k_min), target_k=target, effective_k=self.set_k, active=True) self.set_k = target return dict(ramp=self._ramp_view()) def _ramp_view(self): r = self.ramp return dict(gradient_k_min=r['gradient'], target_k=r['target_k'], effective_k=r['effective_k'] if r['active'] else self.set_k, active=r['active']) def _cmd_unit_set(self, unit): self._need_active() self.unit = unit return dict(unit=unit) def _cmd_display_cycle(self): self._need_active() pages = ['setp', 'flap', 'safety', 'timer', 'ramp', 'usb'] self.page = pages[(pages.index(self.page) + 1) % len(pages)] return dict(page=self.page) def _cmd_usb_set_stick(self, inserted): self._need_plant() if not inserted and self.usb['recording']: self.usb.update(recording=False, next_s=None) self._event('warning', 'USB_REMOVED_WHILE_RECORDING', '记录中拔出U盘：记录停止') if not inserted: self.usb['rows'] = [] # the data leave with the stick self.usb['inserted'] = inserted return dict(inserted=inserted) def _cmd_usb_record(self, on, interval_min=None): self._need_active() if not self.usb['inserted']: raise ActionRejected('NO_STICK') if interval_min is not None: self.usb['interval_s'] = 60.0 * interval_min if on and not self.usb['recording']: self.usb.update(recording=True, next_s=round(self.t_grid + DT, 9)) # first row at the next grid point, then every interval self._event('operation', 'USB_START', f'开始USB记录（间隔{self.usb["interval_s"] / 60.0:.0f} min）') elif not on and self.usb['recording']: self.usb.update(recording=False, next_s=None) self._event('operation', 'USB_STOP', '停止USB记录') return dict(usb=self._usb_view()) def _usb_view(self): return dict(inserted=self.usb['inserted'], recording=self.usb['recording'], interval_s=self.usb['interval_s'], rows=len(self.usb['rows'])) def _cmd_usb_read(self, since_s=0.0): self._need_plant() if not self.usb['inserted']: raise ActionRejected('NO_STICK') return dict(header=['time_s', 'timer_s', 'actual_c', 'setpoint_c', 'fan', 'flap', 'safety_c', 'heating_percent'], rows=[r for r in self.usb['rows'] if r['time_s'] >= since_s]) def _cmd_rack_set(self, level, present): self._need_plant() self._need_door_open() if present: self.racks.add(level) else: if any(s['level'] == level for s in self.samples.values()): raise ActionRejected('RACK_LOADED') self.racks.discard(level) return dict(racks=sorted(self.racks)) def _cmd_sample_place(self, sample_id, level, position, ware, dry_mass_kg, dry_cp_j_kgk=1000.0, dry_density_kg_m3=1500.0, liquid_id=None, liquid_mass_kg=0.0, initial_k=None): self._need_plant() self._need_door_open() if sample_id in self.samples: raise ActionRejected('DUPLICATE_ID') if level not in self.racks: raise ActionRejected('NO_RACK') if any(s['level'] == level and s['position'] == position for s in self.samples.values()): raise ActionRejected('POSITION_OCCUPIED') if liquid_mass_kg > 0.0 and not liquid_id: raise ActionRejected('INVALID_ARGUMENT') w = WARES[ware] t0 = self.plant['ambient_k'] if initial_k is None else float(initial_k) lid = liquid_id if liquid_mass_kg > 0.0 else None if (liquid_mass_kg / LIQ[lid]['density']['value'] if lid else 0.0) + dry_mass_kg / dry_density_kg_m3 > w['capacity_m3'] + 1e-12: raise ActionRejected('OVERFILL') # solid (bulk density, default 1500 kg/m3) and liquid must fit the labware if lid: if (LIQ[lid].get('melting_point_k') or 0.0) >= t0 or t0 >= boiling_k(lid, self.plant['pressure_pa']): raise ActionRejected('NOT_LIQUID') s = dict(level=level, position=position, ware=ware, dry_mass_kg=float(dry_mass_kg), dry_cp=float(dry_cp_j_kgk), liquid_id=lid, liquid_kg=float(liquid_mass_kg), T=t0, evap_kg=0.0, boil_kg=0.0, placed_at=self.t, overheated=False) if self._rack_load(level) + self._sample_mass(s) > DOC['rack_load_kg'] + 1e-9 or \ sum(self._sample_mass(x) for x in self.samples.values()) + self._sample_mass(s) > DOC['total_load_kg'] + 1e-9: raise ActionRejected('OVERLOAD') self.samples[sample_id] = s ta = self.plant['ambient_k'] self.led['e_samples_in_j'] += self._sample_cap(s) * (t0 - ta) self.led['m_placed_kg'] += s['liquid_kg'] self._event('operation', 'SAMPLE_PLACED', f'放入样品{sample_id}（{ware}，第{level}层{position}）') return dict(sample=self._sample_public(sample_id)) def _sample_public(self, sid): s = self.samples[sid] return dict(sample_id=sid, level=s['level'], position=s['position'], ware=s['ware']) def _cmd_sample_remove(self, sample_id): self._need_plant() self._need_door_open() if sample_id not in self.samples: raise ActionRejected('NO_SAMPLE') s = self.samples.pop(sample_id) ta = self.plant['ambient_k'] self.led['e_samples_out_j'] += self._sample_cap(s) * (s['T'] - ta) self.led['m_removed_kg'] += s['liquid_kg'] self._event('operation', 'SAMPLE_REMOVED', f'取出样品{sample_id}') return dict(sample=dict(sample_id=sample_id, ware=s['ware'], ware_mass_kg=WARES[s['ware']]['mass_kg'], total_mass_kg=self._sample_mass(s), dry_mass_kg=s['dry_mass_kg'], liquid_id=s['liquid_id'], liquid_mass_kg=s['liquid_kg'], temperature_k=s['T'], liquid_lost_kg=s['evap_kg'] + s['boil_kg'])) def _cmd_events_read(self, since_s=0.0): return dict(events=[e for e in self.events if e['time_s'] >= since_s], dropped=self.events_dropped) def _cmd_truth_inspect(self): self._need_plant() r = self.read('evaluator') return dict(process=r['truth.process'], faults=r['truth.faults']) def _cmd_ledger_read(self): return dict(ledger=self._ledger()) def _cmd_fault_inject(self, fault, active): self._need_plant() was = self._mains() (self.faults.add if active else self.faults.discard)(fault) if was and not self._mains(): self.outage_since = self.t self._event('alarm', 'POWER_FAILURE', '停电（USB记录中断）') elif not was and self._mains(): if self.class1 and self.t - (self.outage_since or self.t) >= 10.0 - 1e-9: self.class1_reset_armed = True # manual 7.1: after >= 10 s off the alarm clears once below 230 C if self.Ta < CLASS1[1]: self.class1 = False self.class1_reset_armed = False self._event('system', 'OVERTEMP_RESET', '断电≥10 s且已冷却到230 °C以下：1级过温保护复位') self.outage_since = None u = self.usb if u['recording'] and u['next_s'] is not None: # recording was interrupted: the rows of the outage are not written while u['next_s'] <= self.t_grid + 1e-9: u['next_s'] = round(u['next_s'] + u['interval_s'], 9) self._event('system', 'POWER_RESTORED', '来电（控制器恢复原状态；USB记录继续，停电期间无记录）') if active and fault == 'sensor_rupture': self.ctrl.update(i=0.0, d=0.0, e_prev=None) self._event('fault', 'FAULT_' + fault.upper(), f'故障{fault}' + ('：注入' if active else '：清除')) return dict(faults=sorted(self.faults)) def _cmd_sim_step(self, dt_s): return dict(time_s=self.step(dt_s)) # ---- alarms def _alarm_state(self): if self.class1: return 'overtemperature' return {'active': 'limit_active', 'latched': 'limit_latched'}.get(self.alarm2) # ---- physics def _quiet(self): if self.plant is None: return True if self._active(): return False # the controller runs the fan whenever it is on (door closed) if 'ssr_stuck_on' in self.faults and self._mains() and not self.class1 and (self.alarm2 is None or 'safety_controller_failure' in self.faults): return False if any(s['liquid_kg'] > 0.0 for s in self.samples.values()) or any(m > 0.0 for m in self.vapour.values()): return False ta = self.plant['ambient_k'] return all(abs(x - ta) < 1e-9 for x in (self.Th, self.Ta, self.Tl, self.Ts, self.Tsens)) and all(abs(s['T'] - ta) < 1e-9 for s in self.samples.values()) def _quiet_jump(self, t_end): n = int(math.floor((t_end - self.t_grid) / DT + 1e-6)) tm = self.timer if n > 0 and tm['running'] and self._mains(): n = min(n, int(math.ceil(tm['remaining_s'] / DT - 1e-6)) - 1) # the expiry itself is ticked u = self.usb if n > 0 and u['recording'] and self._mains() and u['next_s'] is not None: k = int(math.floor((self.t_grid + n * DT - u['next_s']) / u['interval_s'] + 1e-9)) + 1 if u['next_s'] <= self.t_grid + n * DT + 1e-9 else 0 for i in range(max(k, 0)): # rows written analytically: each with its own timer value and noise sample r_t = u['next_s'] tm_s = max(round(tm['remaining_s'] - (r_t - self.t_grid), 9), 0.0) if tm['running'] else None self._usb_row(r_t, tick=int(round(r_t / DT)) - 1, timer_s=tm_s) u['next_s'] = round(u['next_s'] + u['interval_s'], 9) if n > 0 and tm['running'] and self._mains(): tm['remaining_s'] = round(tm['remaining_s'] - n * DT, 9) return max(n, 0) def step(self, dt_s): if dt_s < 0: raise ActionRejected('INVALID_ARGUMENT') t_end = round(self.t + float(dt_s), 9) if self.plant is None: self.t = t_end self.tick = int(math.floor(t_end / DT + 1e-6)) self.t_grid = round(self.tick * DT, 9) return self.t while self.t_grid + DT <= t_end + 1e-9: if self._quiet(): n = self._quiet_jump(t_end) if n > 0: self.tick += n self.t_grid = round(self.tick * DT, 9) self.t = self.t_grid continue self.t = self.t_grid self._tick(DT) self.tick += 1 self.t_grid = round(self.tick * DT, 9) self.t = self.t_grid self.t = t_end return self.t def _air_change_kg_s(self): """Air exchanged with the room (kg/s): the door-open exchange, or the flap air change (80 /h fully open at 100 C with the fan, datasheet).""" rho = air_density(self.Ta, self.plant['pressure_pa']) if self._door_open(): return ENG['door_open_air_change_per_s'] * V_AIR * rho n = ENG['flap_air_change_per_h'][self.flap] / 3600.0 if not self._fan_on(): n *= ENG['flap_nofan_factor'] return n * V_AIR * rho def _controller(self, h): """PID on the Pt100 reading -> heater duty (0..1); the solid-state relay switches the full heater power for duty x its period.""" c = self.ctrl allowed = self._active() and not self._door_open() and self.alarm2 is None and not self.class1 and not self.timer['expired'] \ and 'sensor_rupture' not in self.faults if not allowed: c.update(duty=0.0, i=0.0, e_prev=None, d=0.0) return 0.0 if self.ramp['active']: r = self.ramp r['effective_k'] = min(r['effective_k'] + r['gradient'] / 60.0 * h, r['target_k']) if r['effective_k'] >= r['target_k'] - 1e-12: r.update(active=False, effective_k=None) self._event('operation', 'RAMP_DONE', '斜坡到达目标设定') e = self._effective_set() - self.Tsens raw = 0.0 if c['e_prev'] is None else (e - c['e_prev']) / h c['e_prev'] = e c['d'] += (raw - c['d']) * h / ENG['pid_d_filter_s'] if abs(e) < ENG['pid_i_band_k']: c['i'] = min(max(c['i'] + ENG['pid_ki_w_ks'] * e * h, 0.0), ENG['heater_power_w']) p = ENG['pid_kp_w_k'] * e + c['i'] + ENG['pid_kd_ws_k'] * c['d'] c['duty'] = min(max(p / ENG['heater_power_w'], 0.0), 1.0) return c['duty'] def _tick(self, h): L = self.led ta = self.plant['ambient_k'] P = self.plant['pressure_pa'] mains = self._mains() # ---- controller and heater duty = self._controller(h) if mains else 0.0 per = ENG['ssr_period_s'] phase = (self.t % per) / per stuck = 'ssr_stuck_on' in self.faults and mains and not self.class1 relay = stuck or (duty > 0.0 and phase < duty - 1e-12) safety_relay_closed = self.alarm2 is None or 'safety_controller_failure' in self.faults # the class 2 limiter opens its own relay heater_ok = 'heater_open' not in self.faults and not self.class1 and mains and safety_relay_closed p_heat = ENG['heater_power_w'] * (self.plant['mains_v'] / 230.0) ** 2 if (relay and heater_ok) else 0.0 self.ctrl['heater_w'] = p_heat fan = self._fan_on() p_fan = ENG['fan_power_w'] if fan else 0.0 # ---- conductances g_ha = ENG['heater_air_w_k'] if fan else ENG['heater_air_nofan_w_k'] g_la = ENG['liner_air_w_k'] if fan else ENG['liner_air_nofan_w_k'] g_ls, g_sa, g_hl = ENG['liner_shell_w_k'], ENG['shell_ambient_w_k'], ENG['heater_liner_w_k'] g_door = ENG['door_open_liner_loss_w_k'] if self._door_open() else 0.0 m_dot = self._air_change_kg_s() q_ha = g_ha * (self.Th - self.Ta) q_hl = g_hl * (self.Th - self.Tl) # the heater sits in the side pre-heating duct of the liner q_la = g_la * (self.Ta - self.Tl) q_ls = g_ls * (self.Tl - self.Ts) q_sa = g_sa * (self.Ts - ta) q_door = g_door * (self.Tl - ta) q_vent = m_dot * CP_AIR * (self.Ta - ta) # ---- samples hs = ENG['sample_h_fan_w_m2k'] if fan else ENG['sample_h_nofan_w_m2k'] km = ENG['evap_mass_transfer_fan_m_s'] if fan else ENG['evap_mass_transfer_nofan_m_s'] q_samples = 0.0 evap_total = {} for sid_, s in self.samples.items(): w = WARES[s['ware']] t_loc = self.Ta + self._offset(s['level'], s['position']) q = hs * w['area_m2'] * (t_loc - s['T']) q_samples += q cap_ = self._sample_cap(s) H = cap_ * (s['T'] - ta) + q * h m_e = m_b = 0.0 lid = s['liquid_id'] if lid and s['liquid_kg'] > 0.0: liq = LIQ[lid] hv, cp_l, mm = liq['enthalpy_vaporization']['value'], liq['heat_capacity']['value'], liq['molar_mass_kg_mol'] tb = boiling_k(lid, P) pv = min(p_vap(lid, min(s['T'], tb)), P) pp = self.vapour.get(lid, 0.0) * R_GAS * self.Ta / (mm * V_AIR) if lid == 'water': pp += self._room_water_pa() X = s['liquid_kg'] / s['dry_mass_kg'] if s['dry_mass_kg'] > 0.0 else math.inf f = min(1.0, X / ENG['critical_moisture_fraction']) m_e = min(max(km * w['open_area_m2'] * (pv - pp) * mm / (R_GAS * s['T']), 0.0) * f * h, s['liquid_kg']) H -= m_e * hv + m_e * cp_l * (s['T'] - ta) s['liquid_kg'] -= m_e cap_ = self._sample_cap(s) t_new = ta + H / cap_ if s['liquid_kg'] > 0.0 and t_new > tb: # boiling: the excess over the boiling point boils liquid off m_b = min((t_new - tb) * cap_ / hv, s['liquid_kg']) H -= m_b * hv + m_b * cp_l * (tb - ta) s['liquid_kg'] -= m_b cap_ = self._sample_cap(s) t_new = ta + H / cap_ if 0.0 < s['liquid_kg'] < 1e-12: # last traces m_e += s['liquid_kg'] s['liquid_kg'] = 0.0 L['e_latent_j'] += (m_e + m_b) * hv L['e_vent_j'] += (m_e * (s['T'] - ta) + m_b * (tb - ta)) * cp_l # the vapour leaves with its sensible heat s['evap_kg'] += m_e s['boil_kg'] += m_b L['m_evaporated_kg'] += m_e L['m_boiled_kg'] += m_b evap_total[lid] = evap_total.get(lid, 0.0) + m_e + m_b s['T'] = t_new else: s['T'] = ta + H / cap_ if s['T'] > MAT[w['material']]['max_service_k']['value'] and not s['overheated']: s['overheated'] = True self._event('truth', 'WARE_OVERHEATED', f'样品{sid_}的器皿超过材料最高使用温度') # ---- node temperatures self.Th += h * (p_heat - q_ha - q_hl) / ENG['heater_heat_capacity_j_k'] self.Ta += h * (q_ha + p_fan - q_la - q_vent - q_samples) / ENG['air_heat_capacity_j_k'] self.Tl += h * (q_la + q_hl - q_ls - q_door) / ENG['liner_heat_capacity_j_k'] self.Ts += h * (q_ls - q_sa) / ENG['shell_heat_capacity_j_k'] # ---- chamber vapour: evaporated in, vented out with the air change m_air = air_density(self.Ta, P) * V_AIR for lid, m in evap_total.items(): self.vapour[lid] = self.vapour.get(lid, 0.0) + m bg_w = self._room_water_pa() # room humidity carried in with the fresh air (background, not tracked) q_cond = 0.0 for lid in list(self.vapour): # above saturation at the air temperature the excess condenses on the mm = LIQ[lid]['molar_mass_kg_mol'] # liner: latent heat back to the air, condensate drained (not re-evaporated) bg = bg_w if lid == 'water' else 0.0 p_i = self.vapour[lid] * R_GAS * self.Ta / (mm * V_AIR) p_sat = min(p_vap(lid, self.Ta), P) if p_i + bg > p_sat: m_c = min((p_i + bg - p_sat) * mm * V_AIR / (R_GAS * self.Ta), self.vapour[lid]) self.vapour[lid] -= m_c L['m_condensed_kg'] += m_c q_cond += m_c * LIQ[lid]['enthalpy_vaporization']['value'] / h L['e_condensation_j'] += q_cond * h self.Ta += h * q_cond / ENG['air_heat_capacity_j_k'] # latent heat of the condensate back to the air p_v = sum(m * R_GAS * self.Ta / (LIQ[lid]['molar_mass_kg_mol'] * V_AIR) for lid, m in self.vapour.items()) + bg_w if p_v > P and p_v > bg_w: # the chamber is open through the exhaust: vapour above the ambient f_keep = max(P - bg_w, 0.0) / (p_v - bg_w) # pressure displaces the gas out of the duct for lid in list(self.vapour): out = self.vapour[lid] * (1.0 - f_keep) self.vapour[lid] -= out L['m_vented_kg'] += out for lid in list(self.vapour): out = min(self.vapour[lid], self.vapour[lid] * m_dot * h / m_air) self.vapour[lid] -= out L['m_vented_kg'] += out if self.vapour[lid] < 1e-15 and not evap_total.get(lid): L['m_vented_kg'] += self.vapour.pop(lid) L['e_heater_j'] += p_heat * h L['e_fan_j'] += p_fan * h L['e_shell_loss_j'] += q_sa * h L['e_door_loss_j'] += q_door * h L['e_vent_j'] += q_vent * h L['e_electric_total_j'] += (p_heat + p_fan + (ENG['controller_power_w'] if mains else 0.0)) * h # ---- Pt100 (lag + noise) tau = ENG['sensor_tau_s'] self.Tsens = self.Ta + (self.Tsens - self.Ta) * math.exp(-h / tau) # ---- safety devices if mains: safety_reading = self.Ta + ENG['safety_sensor_offset_k'] if 'safety_controller_failure' not in self.faults: if safety_reading > self.safe_k and self.alarm2 != 'active': if self.alarm2 is None: self._event('alarm', 'TEMP_LIMIT', '2级安全控制器动作：超过安全设定，加热完全关闭（!TLim）') self.alarm2 = 'active' elif self.alarm2 == 'active' and safety_reading < self.safe_k: self.alarm2 = 'latched' self._event('alarm', 'TEMP_LIMIT_COOLED', '已降到安全设定以下：报警常亮，按OK复位') if self.class1 and self.class1_reset_armed and self.Ta < CLASS1[1]: self.class1 = False self.class1_reset_armed = False self._event('system', 'OVERTEMP_RESET', '重启后腔温降到230 °C以下：1级过温保护报警自动清除') if not self.class1 and self.Ta >= CLASS1[0]: self.class1 = True self.class1_reset_armed = False self._event('alarm', 'OVERTEMPERATURE', '1级过温保护动作（330 °C）：加热切断，须断电≥10 s并冷却') # ---- timer (runs while mains are present) tm = self.timer if mains and tm['running']: tm['remaining_s'] = max(round(tm['remaining_s'] - h, 9), 0.0) if tm['remaining_s'] <= 0.0: tm.update(running=False, expired=True) self._event('operation', 'TIMER_EXPIRED', '延时关闭定时结束：加热关闭' + ('，风机继续' if tm['fan_after'] == 'on' else '，风机停止')) # ---- USB record u = self.usb if mains and u['recording'] and u['next_s'] is not None and self.t + h >= u['next_s'] - 1e-9: self._usb_row(u['next_s'], tick=int(round(u['next_s'] / DT)) - 1) u['next_s'] = round(u['next_s'] + u['interval_s'], 9) # ---- ambient snap (idle only) idle = not self._active() and p_heat == 0.0 and not fan and not self.samples and not self.vapour if idle and all(abs(x - ta) < ENG['ambient_snap_k'] for x in (self.Th, self.Ta, self.Tl, self.Ts)): L['e_ambient_reset_j'] += (ENG['heater_heat_capacity_j_k'] * (self.Th - ta) + ENG['air_heat_capacity_j_k'] * (self.Ta - ta) + ENG['liner_heat_capacity_j_k'] * (self.Tl - ta) + ENG['shell_heat_capacity_j_k'] * (self.Ts - ta)) self.Th = self.Ta = self.Tl = self.Ts = ta if abs(self.Tsens - ta) < ENG['ambient_snap_k']: self.Tsens = ta def _room_water_pa(self): return self.plant['relative_humidity'] * p_vap('water', self.plant['ambient_k']) def _sensor_reading(self, tick=None): return self.Tsens + ENG['sensor_noise_k'] * _gauss(self.seed, self.tick if tick is None else tick, 1) def _usb_row(self, t, tick=None, timer_s=None): """One CSV row at time t; the noise sample is the one of the grid tick ending at t (identical whether the interval is ticked or skipped).""" u = self.usb if len(u['rows']) >= MAX_USB_ROWS: return u['rows'].append(dict(time_s=t, timer_s=(timer_s if timer_s is not None else self.timer['remaining_s']) if self.timer['set_s'] > 0 else None, actual_c=None if 'sensor_rupture' in self.faults else round(self._sensor_reading(tick) - C0, 1), setpoint_c=round(self._effective_set() - C0, 1), fan='on' if self._fan_on() else 'off', flap=FLAP_TEXT[self.flap], safety_c=round(self.safe_k - C0), heating_percent=round(100.0 * self.ctrl['duty']))) # ---- read def _disp_temp(self, k): return k - C0 if self.unit == 'C' else (k - C0) * 9.0 / 5.0 + 32.0 def _display_values(self): if not self._active(): return dict(temp=None, text='') if 'sensor_rupture' in self.faults: temp = 1999.0 else: temp = float(round(self._disp_temp(self._sensor_reading()))) a = self._alarm_state() if a == 'overtemperature': text = 'ALAr OtP' elif a: text = 'ALAr tLI' elif self.timer['expired']: text = 't End' elif self.page == 'setp': text = f'SP{self._disp_temp(self._effective_set()):6.0f}' elif self.page == 'flap': text = f'FL{FLAP_TEXT[self.flap]:>6}' elif self.page == 'safety': text = f'SAFE{self._disp_temp(self.safe_k):4.0f}' elif self.page == 'timer': r = int(math.ceil(self.timer['remaining_s'] - 1e-9)) text = f't {r // 86400:1d}{r % 86400 // 3600:02d}{r % 3600 // 60:02d}' if self.timer['set_s'] > 0 else 't OFF' elif self.page == 'ramp': text = f'r{self.ramp["gradient"]:2d}{self._disp_temp(self.ramp["target_k"]):5.0f}' if self.ramp['gradient'] else 'r OFF' else: text = 'Usb On' if self.usb['recording'] else ('Usb OFF' if self.usb['inserted'] else 'Usb --') return dict(temp=temp, text=text) def read(self, visibility='agent'): pc = self.plant is not None d = self._display_values() if pc else dict(temp=None, text='') act = pc and self._active() out = {'clock.time_s': self.t, 'plant.configured': pc, 'power.on': self.on, 'door.angle_rad': self.door, 'door.open': self._door_open(), 'temperature.set_k': self.set_k, 'safety.limit_k': self.safe_k, 'flap.position': self.flap, 'flap.angle_rad': math.radians(15.0) * self.flap, 'timer.state': self._timer_view(), 'ramp.state': self._ramp_view(), 'unit': self.unit, 'usb.state': self._usb_view(), 'racks.levels': sorted(self.racks), 'samples.placed': [self._sample_public(k) for k in sorted(self.samples)], 'fan.running': bool(pc and self._fan_on()), 'alarm.state': self._alarm_state() if pc else None, 'display.temperature': d['temp'], 'display.text': d['text'], 'indicator.heating': bool(act and self.ctrl['heater_w'] > 0.0), 'indicator.timer': bool(act and (self.timer['running'] or self.timer['expired'])), 'indicator.alarm': bool(act and self._alarm_state() is not None), 'indicator.standby': bool(pc and self._mains() and not self.on)} if visibility != 'agent': out['truth.process'] = (dict(heater_k=self.Th, air_k=self.Ta, liner_k=self.Tl, shell_k=self.Ts, sensor_k=self.Tsens, heater_w=self.ctrl['heater_w'], duty=self.ctrl['duty'], air_change_kg_s=self._air_change_kg_s(), effective_set_k=self._effective_set(), class1_tripped=self.class1, vapour_kg=dict(self.vapour), samples={k: dict(temperature_k=s['T'], local_air_k=self.Ta + self._offset(s['level'], s['position']), liquid_kg=s['liquid_kg'], evaporated_kg=s['evap_kg'], boiled_kg=s['boil_kg'], total_mass_kg=self._sample_mass(s), moisture_ratio=(s['liquid_kg'] / s['dry_mass_kg'] if s['dry_mass_kg'] > 0 else None)) for k, s in self.samples.items()}) if pc else {}) out['truth.faults'] = sorted(self.faults) return out def _ledger(self): if self.led is None: return {} L = dict(self.led) ta = self.plant['ambient_k'] L['h_nodes_j'] = (ENG['heater_heat_capacity_j_k'] * (self.Th - ta) + ENG['air_heat_capacity_j_k'] * (self.Ta - ta) + ENG['liner_heat_capacity_j_k'] * (self.Tl - ta) + ENG['shell_heat_capacity_j_k'] * (self.Ts - ta)) L['h_samples_j'] = sum(self._sample_cap(s) * (s['T'] - ta) for s in self.samples.values()) L['energy_balance_j'] = (L['e_heater_j'] + L['e_fan_j'] + L['e_condensation_j'] + L['e_samples_in_j'] + L['e_reconfigure_j'] - L['e_samples_out_j'] - L['e_shell_loss_j'] - L['e_door_loss_j'] - L['e_vent_j'] - L['e_latent_j'] - L['e_ambient_reset_j'] - L['h_nodes_j'] - L['h_samples_j']) L['m_on_samples_kg'] = sum(s['liquid_kg'] for s in self.samples.values()) L['m_vapour_in_chamber_kg'] = sum(self.vapour.values()) L['mass_balance_kg'] = L['m_placed_kg'] - L['m_evaporated_kg'] - L['m_boiled_kg'] - L['m_removed_kg'] - L['m_on_samples_kg'] L['vapour_balance_kg'] = L['m_evaporated_kg'] + L['m_boiled_kg'] - L['m_vented_kg'] - L['m_condensed_kg'] - L['m_vapour_in_chamber_kg'] return L def _jsonable(o): if isinstance(o, dict): return {str(k): _jsonable(v) for k, v in o.items()} if isinstance(o, (list, tuple)): return [_jsonable(v) for v in o] if isinstance(o, float) and not math.isfinite(o): return None return o # ---------------------------------------------------------------- session (agent / evaluator isolation, idempotency) class BinderFd056Session: def __init__(self, host, principal_id): self._host = host self._principal = principal_id @property def _role(self): return self._host._principals[self._principal] def _target(self, instance_id): if not isinstance(instance_id, str) or instance_id != self._host.instance_id: raise ActionRejected('UNKNOWN_INSTANCE') def describe(self, *, instance_id=None, asset_type_id=None): if (instance_id is None) == (asset_type_id is None): raise ActionRejected('INVALID_ARGUMENT') if instance_id is not None: self._target(instance_id) if asset_type_id is not None and asset_type_id != ASSET_TYPE_ID: raise ActionRejected('UNKNOWN_INSTANCE') meta = copy.deepcopy(export_binder_fd056_contract_metadata()) caps = {k: v for k, v in meta['capabilities'].items() if v['visibility'] == 'agent' or self._role != 'agent'} slots = {k: v for k, v in meta['state_slots'].items() if v['visibility'] == 'agent' or self._role != 'agent'} if self._role == 'agent': for c in caps.values(): c['state_effects'] = [e for e in c['state_effects'] if e['state_id'] in slots] c['observes'] = [x for x in c['observes'] if x in slots] for pre in c['preconditions']: pre['state_ids'] = [x for x in pre['state_ids'] if x in slots] c['execution']['completion_state_ids'] = [x for x in c['execution']['completion_state_ids'] if x in slots] for m in meta['mechanisms'].values(): m['state_ids'] = [x for x in m['state_ids'] if x in slots] return dict(protocol_version=PROTOCOL_VERSION, asset_type_id=ASSET_TYPE_ID, asset_version='1.0.0', capabilities=caps, state_slots=slots) def read(self, *, instance_id, state_ids=None): self._target(instance_id) h = self._host values = _jsonable(h.read(self._role)) ids = list(values) if state_ids is None else state_ids if not isinstance(ids, list) or any(not isinstance(k, str) for k in ids): raise ActionRejected('INVALID_ARGUMENT') if any(k not in values for k in ids): raise ActionRejected('ACCESS_DENIED') return dict(instance_id=instance_id, status='succeeded', state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s}, observations={k: dict(value=copy.deepcopy(values[k]), unit=SLOTS[k]['unit'], quality='unavailable' if values[k] is None else 'estimated' if SLOTS[k]['origin'] in ('sensor', 'derived') else 'valid', sample_time_s=h.time_s, sample_window_s=None) for k in ids}) def invoke(self, *, instance_id, capability_id, arguments, request_id): h = self._host key = digest = None try: self._target(instance_id) if not isinstance(request_id, str) or not request_id: raise ActionRejected('INVALID_ARGUMENT') key = (self._principal, request_id) try: digest = json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False) except (TypeError, ValueError): digest = None if key in h._requests: old, response = h._requests[key] if digest is None or old != digest or not isinstance(response, dict): raise ActionRejected('REQUEST_CONFLICT') return copy.deepcopy(response) if not isinstance(capability_id, str) or capability_id not in CAPS: raise ActionRejected('UNKNOWN_CAPABILITY') if self._role == 'agent' and CAPS[capability_id]['visibility'] != 'agent': raise ActionRejected('ACCESS_DENIED') if not isinstance(arguments, dict): raise ActionRejected('INVALID_ARGUMENT') validate(CAPS[capability_id]['input_schema'], arguments) h._caller = self._principal snapshot = copy.deepcopy({k: v for k, v in h.__dict__.items() if k not in ('_principals', '_requests', '_caller')}) try: result = _jsonable(h.invoke(capability_id, **arguments)) except ActionRejected: h.__dict__.update(snapshot) # rejected: nothing changed raise finally: h._caller = None if self._role == 'agent' and capability_id == 'events.read': result = dict(events=[e for e in result['events'] if e['kind'] not in ('fault', 'truth')], dropped=result['dropped']) response = dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=None, status='succeeded', state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s}, result=copy.deepcopy(result), observations={}, error=None) h._requests[key] = (digest, copy.deepcopy(response)) return response except ActionRejected as exc: response = dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=None, status='unsupported' if str(exc) == 'UNSUPPORTED' else 'rejected', state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s}, result={}, observations={}, error=dict(code=str(exc), message=ERROR_ZH.get(str(exc), str(exc)), retryable=False, side_effects='none')) if key is not None and digest is not None and key not in h._requests: h._requests[key] = (digest, copy.deepcopy(response)) return response def write(self, *, instance_id, state_id, value, request_id): self._target(instance_id) raise ActionRejected('ACCESS_DENIED') def poll(self, operation_id): raise ActionRejected('UNKNOWN_OPERATION') def cancel(self, operation_id, request_id): raise ActionRejected('UNKNOWN_OPERATION') # ---------------------------------------------------------------- contract metadata ERROR_ZH = { 'INVALID_ARGUMENT': '参数不符合输入模式或取值范围', 'REQUEST_CONFLICT': '同一request_id对应不同的调用', 'UNKNOWN_INSTANCE': '实例不存在', 'UNKNOWN_CAPABILITY': '能力不存在', 'UNSUPPORTED': '本型号或本配置没有该功能', 'ACCESS_DENIED': '无权访问（真值或评测者能力）', 'UNKNOWN_OPERATION': '会话不支持该操作（本运行层的能力都是同步的）', 'PLANT_REQUIRED': '尚未声明环境', 'SEED_FIXED': '噪声种子只能在首次声明时设定', 'NO_MAINS': '停电（控制器不工作）', 'STANDBY': '控制器在待机（先按住待机键约3 s）', 'DOOR_CLOSED': '门关着（先开门）', 'NO_STICK': '没有插U盘', 'RACK_LOADED': '该层搁架上还有样品', 'DUPLICATE_ID': '样品编号已存在', 'NO_RACK': '该层没有搁架', 'POSITION_OCCUPIED': '该位置已有样品', 'OVERFILL': '液体与固体超过器皿容量', 'NOT_LIQUID': '液体在此温度下不是液体（低于熔点或高于沸点；改环境时：样品上的液体会凝固，凝固未建模）', 'OVERLOAD': '超过每层30 kg或总负载70 kg', 'NO_SAMPLE': '没有该样品', } _P = ['PLANT_REQUIRED'] _A = _P + ['NO_MAINS', 'STANDBY'] CAP_ERRORS = { 'plant.configure': ['SEED_FIXED', 'NOT_LIQUID'], 'power.set': _P + ['NO_MAINS'], 'power.toggle': _P + ['NO_MAINS'], 'door.set': _P, 'temperature.set': _A, 'temperature.step': _A, 'safety.set_limit': _A, 'alarm.acknowledge': _A, 'flap.set': _A, 'timer.set': _A, 'ramp.set': _A, 'unit.set': _A, 'display.cycle': _A, 'usb.set_stick': _P, 'usb.record': _A + ['NO_STICK'], 'usb.read': _P + ['NO_STICK'], 'rack.set': _P + ['DOOR_CLOSED', 'RACK_LOADED'], 'sample.place': _P + ['DOOR_CLOSED', 'DUPLICATE_ID', 'NO_RACK', 'POSITION_OCCUPIED', 'OVERFILL', 'NOT_LIQUID', 'OVERLOAD', 'INVALID_ARGUMENT'], 'sample.remove': _P + ['DOOR_CLOSED', 'NO_SAMPLE'], 'events.read': [], 'truth.inspect': _P, 'ledger.read': [], 'fault.inject': _P, 'sim.step': [], } _COMMON_ERRORS = ['INVALID_ARGUMENT', 'REQUEST_CONFLICT', 'UNKNOWN_INSTANCE'] _CTRL = ('有电且不在待机', ['power.on']) PRECONDITIONS = { 'plant.configure': ('首次声明时设定噪声种子（之后不可改）；样品上有液体时室温须高于其熔点', ['plant.configured', 'samples.placed']), 'power.set': ('有电', ['power.on']), 'power.toggle': ('有电', ['power.on']), 'door.set': ('无', ['door.angle_rad']), 'temperature.set': _CTRL, 'temperature.step': _CTRL, 'safety.set_limit': _CTRL, 'alarm.acknowledge': ('有电且不在待机；报警须已降到安全设定以下才会复位', ['power.on', 'alarm.state']), 'flap.set': _CTRL, 'timer.set': _CTRL, 'ramp.set': ('有电且不在待机；目标高于实际温度时才按梯度运行', ['power.on', 'ramp.state']), 'unit.set': _CTRL, 'display.cycle': _CTRL, 'usb.set_stick': ('无', ['usb.state']), 'usb.record': ('有电且不在待机；已插U盘', ['power.on', 'usb.state']), 'usb.read': ('已插U盘', ['usb.state']), 'rack.set': ('门开着；取出时该层无样品', ['door.open', 'racks.levels', 'samples.placed']), 'sample.place': ('门开着；该层有搁架且位置空；液体在初温为液体；不超过器皿容量与搁架30 kg、总70 kg', ['door.open', 'racks.levels', 'samples.placed']), 'sample.remove': ('门开着；样品存在', ['door.open', 'samples.placed']), 'truth.inspect': ('无', ['plant.configured']), 'fault.inject': ('无', ['plant.configured']), } _DISPLAY = ['display.temperature', 'display.text'] _IND = ['indicator.heating', 'indicator.timer', 'indicator.alarm', 'indicator.standby'] _EVOLVE = _DISPLAY + _IND + ['fan.running', 'alarm.state', 'timer.state', 'ramp.state', 'usb.state', 'truth.process'] EFFECTS = { 'plant.configure': ['plant.configured', 'truth.process'] + _DISPLAY + _IND + ['fan.running', 'alarm.state'], 'power.set': ['power.on', 'fan.running', 'truth.process'] + _DISPLAY + _IND, 'power.toggle': ['power.on', 'fan.running', 'truth.process'] + _DISPLAY + _IND, 'door.set': ['door.angle_rad', 'door.open', 'fan.running', 'truth.process', 'indicator.heating'], 'temperature.set': ['temperature.set_k', 'ramp.state', 'display.text', 'truth.process'], 'temperature.step': ['temperature.set_k', 'ramp.state', 'display.text', 'truth.process'], 'safety.set_limit': ['safety.limit_k', 'display.text'], 'alarm.acknowledge': ['alarm.state', 'timer.state', 'fan.running', 'indicator.alarm', 'indicator.timer', 'display.text', 'truth.process'], 'flap.set': ['flap.position', 'flap.angle_rad', 'display.text', 'truth.process'], 'timer.set': ['timer.state', 'indicator.timer', 'display.text'], 'ramp.set': ['temperature.set_k', 'ramp.state', 'display.text', 'truth.process'], 'unit.set': ['unit', 'display.temperature', 'display.text'], 'display.cycle': ['display.text'], 'usb.set_stick': ['usb.state', 'display.text'], 'usb.record': ['usb.state', 'display.text'], 'usb.read': [], 'rack.set': ['racks.levels'], 'sample.place': ['samples.placed', 'truth.process'], 'sample.remove': ['samples.placed', 'truth.process'], 'fault.inject': ['truth.faults', 'fan.running', 'alarm.state', 'truth.process'] + _DISPLAY + _IND, 'sim.step': ['clock.time_s'], } _STEPPED = ('plant.configure', 'power.set', 'power.toggle', 'door.set', 'temperature.set', 'temperature.step', 'safety.set_limit', 'alarm.acknowledge', 'flap.set', 'timer.set', 'ramp.set', 'sample.place', 'sample.remove', 'fault.inject', 'usb.record') ON_STEP = {k: list(_EVOLVE) for k in _STEPPED} ON_STEP['sim.step'] = _EVOLVE + ['clock.time_s'] ON_STEP_ZH = {'sim.step': '按0.1 s网格积分：加热器、空气、内胆、外壳与样品温度，换气，样品干燥与腔内蒸气，Pt100，控温与斜坡，安全装置，定时，USB记录；' '待机或停电、全部在室温且无湿样品时整段跳过（定时与USB记录解析推进）'} EXEC_TEXT = {} RESOURCES = {k: ['host_clock'] for k in CAPS} for _k in ('door.set', 'usb.set_stick', 'rack.set', 'sample.place', 'sample.remove'): RESOURCES[_k] = ['host_clock', 'robot_or_operator'] OBSERVES = {'temperature.set': ['display.temperature'], 'power.set': ['display.temperature', 'indicator.standby'], 'door.set': ['fan.running'], 'usb.record': ['usb.state']} _WB, _DS, _MAN, _MATS, _NIST, _PC, _LIB, _SIM = ('user_workbook', 'manufacturer_datasheet', 'manufacturer_manual_2017', 'material_datasheets', 'nist_webbook', 'pubchem', 'liquid_library', 'simulation_assumption') CAP_SOURCES = {k: [_DS, _MAN] for k in CAPS} CAP_SOURCES.update({'plant.configure': [_DS, _WB, _SIM], 'sample.place': [_MATS, _NIST, _PC, _LIB, _SIM], 'sample.remove': [_SIM], 'events.read': [_MAN, _SIM], 'truth.inspect': [_SIM], 'ledger.read': [_SIM], 'fault.inject': [_MAN, _SIM], 'sim.step': [_SIM], 'door.set': [_DS, _MAN], 'rack.set': [_DS, _MAN]}) PARAM_ZH = {'ambient_k': '室温', 'pressure_pa': '大气压', 'mains_v': '电源电压', 'noise_seed': '噪声种子', 'relative_humidity': '室内相对湿度', 'on': '开或待机', 'angle_rad': '门开角', 'temperature_k': '温度设定', 'delta_k': '设定增减', 'limit_k': '安全控制器设定', 'position': '风门开度0–4或搁架位置', 'days': '天', 'hours': '时', 'minutes': '分', 'fan_after': '定时结束后风机', 'gradient_k_min': '斜坡梯度（°C/min）', 'target_k': '斜坡目标', 'unit': '温度单位', 'inserted': 'U盘插入', 'interval_min': '记录间隔', 'since_s': '起始时间', 'level': '搁架层', 'present': '放入或取出', 'sample_id': '样品编号', 'ware': '器皿（目录）', 'dry_mass_kg': '干固体质量', 'dry_cp_j_kgk': '干固体比热', 'liquid_id': '湿液体（模板库）', 'liquid_mass_kg': '液体质量', 'initial_k': '样品初温', 'fault': '故障名', 'active': '注入或清除', 'dt_s': '推进时间'} _DEFAULT_LIMIT = '过程层实现；机器人与硬件层未实现；整体模型边界见mechanisms.drying_oven_process.limitations。' CAP_LIMITS = { 'sample.place': ['器皿材料与尺寸来自目录（工程尺寸，材料物性有来源）；干固体只有质量与比热（不吸附、不分解）；湿液体为模板库中的单一纯液体；不建模溶剂可燃性与爆炸下限（手册：本机不用于可燃物）。'], 'display.cycle': ['R4菜单的方向键/OK/返回导航被抽象为直接能力（设定、风门、安全、定时、斜坡、USB）；返回键在场景中切换文字行页面。'], 'temperature.step': ['场景中上、下键各按一次=±1 K（菜单中按住连续变化未建模）。'], 'usb.read': ['CSV内容按手册列出的量；日期时间以仿真时钟秒表示；文件名与语言格式未建模。'], } LIMITATIONS = [ '所选配置：BINDER FD 56（FD056-230V，9010-0303），标准配置（2层镀铬搁架，无选件）；数据表2022版为主来源，手册E3.1（12/2017）补充控制器与安全装置细节。', '热模型：加热器、腔内空气、内胆（含搁架与风扇）、隔热层与外壳四个集总节点；内胆热容、内胆—外壳导热与开门换气各1项标定（15 min到150 °C、150 °C能耗290 W、开门30 s后4 min恢复）；' '其余传热系数为工程值；空间温差按数据表±1.7 K（150 °C）的形状场给出，不是CFD。', '控温：Pt100一阶滞后加噪声，PID加固态继电器周期为工程实现，复核数据表±0.3 K波动；BINDER R4的实际控制算法未公开。', '换气：风门5档按15°步进，全开为数据表80次/h（100 °C），中间档与关闭漏风为工程值；风机停止时只靠热浮力（工程倍数）；开门时加热与风机停止（手册）。', '1级过温保护的复位需要拔掉电源≥10 s：本资产中只有评测者的mains_outage故障模拟断电，代理的power.set只是待机，不能复位1级过温保护（拔插电源的机器人动作未建模）。', '安全：安全控制器读数取腔内空气温度（无偏差假设）；300 °C设定配300 °C安全设定（均为上限）时，控温波动可触发限温报警（手册建议安全设定比温度设定高2–5 °C，最高温度下无法满足）。' '2级安全控制器（限温器）超过设定后完全关闭加热并锁定，降到设定以下后按OK复位；1级过温保护330 °C切断，断电≥10 s且冷却到230 °C以下才复位；出厂安全设定未知，取最大300 °C（假设）。', '样品：器皿+干固体（堆积密度默认1500 kg/m³，可声明；固体与液体须装得下）+一种液体；恒速干燥段按湿表面传质（风机开/关两档系数），含湿量低于临界值（工程值0.15）后线性降速；沸点以上过剩热量使液体沸腾；腔内蒸气随换气排出（各蒸气不超过腔温下的饱和蒸气压，超出部分在内胆上冷凝、放出汽化热、冷凝液排走不再蒸发；总蒸气分压不超过大气压，超出部分经排气管挤出），' '水的背景按室内相对湿度；不建模冷凝液的再蒸发、吸湿、化学变化与可燃气氛。', 'FD为固定风速；延时开启、温度相关延时关闭、风速设定与各选件为unsupported；R4菜单导航（方向键/OK/返回的逐级操作）被抽象为直接能力，场景中五个按键为弹簧键。', '显示文字按七段字形：设定“SP”、风门“FL CLOS/1/2/3/OPEn”、安全“SAFE”、定时“t dhhmm”、斜坡“r”、USB“Usb”、2级报警“ALAr tLI”（手册!TLim）、1级“ALAr OtP”、定时结束“t End”；' '大数字为实际温度（Pt100断线显示1999）。', '场景：箱体、门（双向关节）、三角控制面板（显示、5键）、内腔、2层搁架、风扇罩、排气管与后部风门执行器（随风门开度转动）有几何；样品没有几何（运行层状态）。', ] def _sampling_text(k): if k == 'clock.time_s': return 'Host clock.' if SLOTS[k]['origin'] in ('sensor', 'derived', 'process_truth'): return 'Updated on the 0.1 s grid of the host steps (display values as the controller shows them).' return 'Changes when a command is accepted.' def _errors_of(k): if k in UNSUPPORTED: return ['UNSUPPORTED'] + _COMMON_ERRORS extra = ['ACCESS_DENIED'] if CAPS[k]['visibility'] != 'agent' else [] return list(dict.fromkeys(CAP_ERRORS.get(k, []) + _COMMON_ERRORS + extra)) def _pre_text(k): errs, text = CAP_ERRORS.get(k, []), PRECONDITIONS[k][0] if 'PLANT_REQUIRED' in errs and '声明' not in text: text = '已声明环境（否则PLANT_REQUIRED）；' + text return text def _pre_slots(k): errs = CAP_ERRORS.get(k, []) ids = (['plant.configured'] if 'PLANT_REQUIRED' in errs else []) + list(PRECONDITIONS[k][1]) return list(dict.fromkeys(ids)) def _model_effects(k, un): if un: return dict(mode='none', description_zh='不支持：无模型变化', binding_ids=[]) seen = sorted((set(EFFECTS.get(k, [])) | set(ON_STEP.get(k, []))) & SCENE_MIRRORED) if seen: return dict(mode='host_required', binding_ids=[], description_zh='状态经宿主桥（Matterix）镜像到场景（' + '、'.join(seen) + '；绑定见合同model_bindings），运行层本身不驱动模型') return dict(mode='none', description_zh='过程或设定变化，没有对应的场景关节、读数或指示灯', binding_ids=[]) def _params(): P = {} def si(name, val, unit): """Contract parameters in SI: degC -> K, min -> s, deg -> rad, in -> m (the source value is noted in the meaning).""" conv = {'degC': ('K', lambda x: x + C0, '_c', '_k'), 'min': ('s', lambda x: x * 60.0, '_min', '_s'), 'deg': ('rad', math.radians, '_deg', '_rad'), 'K/min': ('K/s', lambda x: x / 60.0, '', '_k_s'), '1/h': ('1/s', lambda x: x / 3600.0, '_per_h', '_per_s')} if unit not in conv: return name, val, unit, '' u, f, a, b = conv[unit] val2 = ({kk: (f(x) if isinstance(x, (int, float)) else x) for kk, x in val.items()} if isinstance(val, dict) else [f(x) if isinstance(x, (int, float)) else x for x in val] if isinstance(val, list) else f(val)) return (name[:-len(a)] + b if a and name.endswith(a) else name + b), val2, u, f'（换算为SI；资料原值{val} {unit}）' def doc(name, val, unit, meaning, src): name, val, unit, extra = si(name, val, unit) P[name.lower()] = dict(value=val, unit=unit, meaning_zh=meaning + extra, evidence='documented', source_ids=list(src), uncertainty=None) def asm(name, val, unit, meaning, unc, src=(_SIM,)): name, val, unit, extra = si(name, val, unit) P[name.lower()] = dict(value=val, unit=unit, meaning_zh=meaning + extra, evidence='assumption', source_ids=list(src), uncertainty=unc) src_of = {'manufacturer_datasheet': _DS, 'manufacturer_manual_2017': _MAN} WB_KEYS = ('temperature_range_above_ambient_k', 'temperature_max_c', 'temperature_variation_150_k', 'temperature_fluctuation_150_k', 'heating_up_150_s', 'rated_voltage_v', 'nominal_power_w', 'interior_volume_m3', 'housing_dimensions_m', 'net_weight_kg') for k, v in instrument()['documented'].items(): doc(k, v['value'], v['unit'], v['note_zh'] + '（原文：' + v['quote'] + '）', (src_of[v['source_id']],) + ((_WB,) if k in WB_KEYS else ())) for k in sorted(ENG): ev = instrument()['engineering'][k]['evidence'] asm(k, ENG[k], ENG_UNIT.get(k, '1'), ENG_NOTE[k], '已标定（calibrate_oven.py），模型自洽，不是实测' if ev == 'calibrated' else '由厂家图纸或数据推得' if ev in ('drawing', 'documented_derived') else '工程值（见instrument_model.json的engineering说明），不是实测') for k, v in instrument()['derived'].items(): asm(k, v['value'], v['unit'], '由厂家数据推导：' + v['note_zh'], '推导值', (_DS, _MAN)) lt = _lib('loads') asm('load_templates', dict(file='assets/expansion_batch05/t4_measure/binder_fd056/load_templates.json', counts=lt['counts']), '1', '装载模板：器皿材料（厂家数据表、NIST、PubChem）与湿液体（CHEM-008液体模板库，NIST/PubChem）；每条带来源', '实测文献数据；适用规则见模板库rules_zh', (_MATS, _NIST, _PC, _LIB)) asm('gas_constant_j_mol_k', R_GAS, 'J/(mol K)', '气体常数', '物理常数', (_SIM,)) asm('air_cp_j_kgk', CP_AIR, 'J/(kg K)', '空气定压比热（25–150 °C平均）', '物理常数（工程取值）', (_SIM,)) return P SLOT_REFERENCE = {'display.temperature': '显示的实际腔温（控制传感器位置，°C或°F整数）'} def export_binder_fd056_contract_metadata(): slots, caps = {}, {} for k, v in SLOTS.items(): slots[k] = dict(meaning_zh=v['meaning'], component_ids=[v['component']], value_schema=copy.deepcopy(v['schema']), unit=v['unit'], reference_conditions=SLOT_REFERENCE.get(k), origin=v['origin'], visibility=v['visibility'], access='read_only', read_binding=dict(backend='host', artifact_id='runtime', accessor=f'BinderFd056Session.read(state_ids=[{k!r}])'), write_via=None, sampling=dict(mode='instant', time_domain='simulation', window_description=_sampling_text(k)), source_ids=['simulation_assumption']) for k, v in CAPS.items(): un = k in UNSUPPORTED c = {key: copy.deepcopy(v[key]) for key in ['input_schema', 'output_schema', 'component_ids', 'function_zh', 'kind', 'visibility', 'example_arguments']} c.update(availability='unsupported' if un else 'implemented', implementation={layer: 'absent' if un or layer in ('scene', 'robot', 'hardware') else 'implemented' for layer in ['process', 'scene', 'robot', 'hardware', 'host']}, binding=None if un else dict(backend='host', artifact_id='runtime', entrypoint='asset_runtime.binder_fd056.BinderFd056Session.invoke', invocation=f'session.invoke(instance_id="binder_fd056_01",capability_id={k!r},arguments={v["example_arguments"]!r},request_id="unique")'), preconditions=[] if un or k not in PRECONDITIONS else [dict(description_zh=_pre_text(k) + '；被拒时状态不变。', state_ids=_pre_slots(k), enforced_by='runtime', check='BinderFd056Runtime.invoke')], state_effects=[dict(state_id=s, timing='on_step' if k == 'sim.step' else 'immediate', description_zh='设定或立即改变的量') for s in dict.fromkeys(EFFECTS.get(k, []))], observes=[] if un else list(OBSERVES.get(k, [])), model_effects=_model_effects(k, un), execution=dict(mode='synchronous', time_domain='simulation', completion_criterion=EXEC_TEXT[k][0] if k in EXEC_TEXT else '原子设定、配置或查询（温度与样品在之后的step中演化）', completion_state_ids=[], timeout_s=None, cancellation='unsupported', retry='same_request_id', resources=list(RESOURCES.get(k, [])), partial_failure_zh=('不支持：不执行，状态不变' if un else '同步原子操作：成功时一次写入全部效果，被拒时状态不变')), errors=[dict(code=e, meaning_zh=ERROR_ZH.get(e, e), side_effects='none') for e in _errors_of(k)], verification=[], limitations=[UNSUPPORTED[k]] if un else list(CAP_LIMITS.get(k, [_DEFAULT_LIMIT])), source_ids=list(CAP_SOURCES[k])) if k in ON_STEP: c['state_effects'] += [dict(state_id=s, timing='on_step', description_zh=ON_STEP_ZH.get(k, '随step演化')) for s in dict.fromkeys(ON_STEP[k]) if not (k == 'sim.step' and s in EFFECTS.get(k, []))] caps[k] = c mechanism = dict( component_ids=['housing', 'door', 'panel', 'liner', 'fan_cover', 'exhaust_duct', 'flap_actuator', 'display'], state_ids=list(slots), implementation='lumped', meaning_zh='强制对流干燥：加热器加热循环空气，风机把热空气吹过搁架上的器皿与样品；排气风门调节新风换气；R4控制器用Pt100按设定（可带斜坡）PID控温；' '2级安全控制器与1级过温保护切断加热；开门时加热与风机停止；样品中的液体按湿表面传质蒸发，蒸气随换气排出', equations=['C_h dT_h/dt = P_heat - G_ha (T_h - T_a) - G_hl (T_h - T_l); C_a dT_a/dt = G_ha (T_h - T_a) + P_fan - G_la (T_a - T_l) - m_dot c_p (T_a - T_amb) - sum h A_i (T_a + dT_i - T_i)', 'C_l dT_l/dt = G_la (T_a - T_l) + G_hl (T_h - T_l) - G_ls (T_l - T_s) - G_door (T_l - T_amb); C_s dT_s/dt = G_ls (T_l - T_s) - G_sa (T_s - T_amb)', 'm_dot = n(flap) / 3600 V_steam rho_air(T_a) (x f_nofan without fan); door open: m_dot = k_door V rho', 'C_i dT_i/dt = h A_i (T_a + dT_i - T_i) - m_evap h_vap; m_evap = k_m A_open (p_vap(T_i) - p_partial) M / (R T_i) min(1, X / X_crit)', 'dT_i = 1.7 K x shape(level, position) x (T_a - T_amb) / 128 K (x 1.6 flap open, x 4 fan off)', 'duty = clamp((Kp e + Ki int e + Kd de/dt) / P_heater, 0, 1); heater on for duty x SSR period; heating off when T_safety > limit (latched)'], parameters=_params(), source_ids=[_SIM, _WB, _DS, _MAN, _MATS, _NIST, _PC, _LIB], limitations=list(LIMITATIONS)) import importlib.util spec = importlib.util.spec_from_file_location('_binder_fd056_local_annotations', ROOT / 'scripts/asset_runtime/_annotations.py') ann = importlib.util.module_from_spec(spec) spec.loader.exec_module(ann) ann.KEY_ZH.update({k: v['meaning'] for k, v in SLOTS.items()}) ann.PARAM_ZH.update(PARAM_ZH) ann.annotate_export('binder_fd056', caps, slots, {'drying_oven_process': mechanism}, inputs={'plant.configure': (PLANT, PLANT_EXAMPLE), 'sample.place': (SAMPLE, SAMPLE_EXAMPLE)}) for k, v in SLOTS.items(): slots[k]['meaning_zh'] = v['meaning'] if SLOT_REFERENCE.get(k): slots[k]['reference_conditions'] = SLOT_REFERENCE[k] return dict(asset_type_id=ASSET_TYPE_ID, catalog_id=CATALOG_ID, capabilities=caps, state_slots=slots, mechanisms={'drying_oven_process': mechanism})