| """4TE cold-mirror water activity: measured solution points, conservative water ledger. |
| |
| 1.1.0 device layer (AQUALAB 4 manual 18280-6, 'aq p.N' = PDF page; the 2019 Series 4 manual 13484-15 for the on-instrument %Moisture |
| calibration): device clock, regional formatting, autosave and the data store (view, annotate, delete all), beeps, serial print mode, product |
| isotherm models (select, offset, copy, delete), ISO 18787 mode, administrator / users / access, and the front panel (panel_ui.json beside the |
| contract, run by the generic engine _panel_ui.py on top of these capabilities: 128 x 64 LCD, four arrow keys, three round context keys, the |
| chamber lever and the power switch). 1.2.0: evaluator fault injection of the four error messages of aq p.58 Table 6, panel readings owned by |
| the gesturing caller.""" |
| from __future__ import annotations |
| import copy,datetime,hashlib,json,math,os,tempfile,weakref |
| from asset_runtime import _annotations as _ann |
| from pathlib import Path |
| from asset_runtime.mt_hx204 import ActionRejected,number,obj,BOOL,TEXT,PHASE |
| from asset_runtime.antonpaar_abbematadvanced import validate |
| ROOT=Path(__file__).resolve().parents[2];ASSET_TYPE_ID='instrument.aqualab_4te';CATALOG_ID='CHEM-007';PROTOCOL_VERSION='1.0.0' |
| TEMPLATE_REL='assets/reactions/aqualab_4te_water_activity_library/templates.json' |
| TEMP=number('K',288.15,323.15);AW=number('1',.03,1.);NULL_AW={'anyOf':[AW,{'type':'null'}]};ANGLE=number('rad',0,math.pi/2);NULL_NUM={'anyOf':[number('1',0),{'type':'null'}]} |
| MODE={'type':'string','enum':['single','continuous','custom','low_emitting','iso18787']} |
| RESULT=obj({'water_activity':NULL_AW,'temperature_k':TEMP,'equilibrated':BOOL,'phase':PHASE,'quality':TEXT,'evidence':TEXT,'template_source':TEXT,'moisture_dry_basis':NULL_NUM,'moisture_evidence':TEXT}) |
| CAPS={ |
| 'power.set':(obj({'enabled':BOOL}),obj({'enabled':BOOL}),['power_inlet','button_power'],'电源设定，断电取消；预热状态单独读出','device_command','agent',{'enabled':True},['power.enabled','cycle.phase','warmup.elapsed_s']), |
| 'thermal.set_temperature':(obj({'temperature_k':TEMP}),obj({'temperature_k':TEMP}),['sample_peltier','mirror_peltier'],'15–50C、0.1C步进目标，设置不推进温度','device_command','agent',{'temperature_k':298.15},['thermal.target_k','water_activity.indicated']), |
| 'lid.set_angle':(obj({'angle_rad':ANGLE}),obj({'angle_rad':ANGLE}),['lid'],'锁杆释放后才能开盖；被动盖宿主姿态，不是机器人技能','device_command','agent',{'angle_rad':math.pi/2},['lid.angle_rad']), |
| 'latch.set_angle':(obj({'angle_rad':ANGLE}),obj({'angle_rad':ANGLE}),['lever_lock'],'闭盖后锁定READ；释放锁杆取消采集','device_command','agent',{'angle_rad':0.},['latch.angle_rad','cycle.phase']), |
| 'sample.configure':(obj({'substance_id':TEXT,'record_index':number('1',0),'mass_kg':number('kg',1e-5,.02),'volume_m3':number('m^3',1e-7,7e-6),'matrix_id':TEXT,'initial_temperature_k':TEMP,'equilibration_tau_s':number('s',5,600),'volatile_interference':BOOL}),obj({'configured':BOOL}),['sample_cup','cup_interface'],'宿主装样，选择实测溶液组成；质量和体积为独立输入，非隐含密度换算','configuration','evaluator',{'substance_id':'sodium_chloride','record_index':0,'mass_kg':.003,'volume_m3':3e-6,'matrix_id':'salt','initial_temperature_k':298.15,'equilibration_tau_s':35.,'volatile_interference':False},['sample.loaded','sample.input_kg','sample.retained_kg','water_activity.indicated']), |
| 'sample.unload':(obj({}),obj({'unloaded':BOOL}),['sample_cup','cup_interface'],'开盖后宿主移出样品，守恒账本保留实际水分交换','configuration','evaluator',{},['sample.loaded','sample.retained_kg','sample.removed_kg']), |
| 'method.configure':(obj({'mode':MODE,'stability_delta':number('1',.0003,.02),'temperature_tolerance_k':number('K',.1,4.),'consecutive_readings':number('1',1,9)}),obj({'configured':BOOL}),['display_digits'],'单次、连续、自定义与低释放模式的平衡代理，非厂家完整算法','configuration','agent',{'mode':'single','stability_delta':.0005,'temperature_tolerance_k':.5,'consecutive_readings':1},['method.mode','equilibrium.stable']), |
| 'calibration.configure':(obj({'offset_aw':number('1',-.03,.03),'source':TEXT}),obj({'offset_aw':number('1',-.03,.03)}),['chilled_mirror','display_digits'],'有来源的线性偏置代理，不宣称真实工厂校准','configuration','agent',{'offset_aw':0.,'source':'synthetic zero-offset example'},['calibration.offset_aw']), |
| 'calibration.verify':(obj({'reference_aw':AW}),obj({'deviation_aw':number('1',-1,1),'within_vendor_tolerance':BOOL}),['chilled_mirror'],'完成预热且最近平衡后对已知标准核查，不自动调参','query','agent',{'reference_aw':.92},[]), |
| 'isotherm.configure':(obj({'matrix_id':TEXT,'temperature_k':TEMP,'source':TEXT,'points':{'type':'array','minItems':2,'maxItems':128,'items':obj({'water_activity':AW,'moisture_dry_basis':number('1',0)})}}),obj({'configured':BOOL}),['display_digits'],'仅输入有来源的特定产品等温线，适用温度内插，不提供通用含水率','configuration','agent',{'matrix_id':'demo','temperature_k':298.15,'source':'synthetic test only','points':[{'water_activity':.1,'moisture_dry_basis':.01},{'water_activity':.99,'moisture_dry_basis':.4}]},['isotherm.configured']), |
| 'acquisition.start':(obj({}),obj({'phase':PHASE,'operation_id':TEXT}),['chilled_mirror','optical_sensor','thermopile','chamber_fan','display_digits'],'闭盖锁紧后按实际稳定判据采集；典型5min非固定周期','device_command','agent',{},['cycle.phase','cycle.elapsed_s','equilibrium.stable']), |
| 'acquisition.stop':(obj({}),obj({'phase':PHASE}),['display_digits'],'停止采集，水分转移和热过程不回滚','device_command','agent',{},['cycle.phase']), |
| 'water_activity.measure':(obj({}),RESULT,['chilled_mirror','thermopile','display_digits'],'纯读水活度、样温和平衡状态；不泄露样品真值','query','agent',{},[]), |
| } |
| SLOTS={ |
| 'power.enabled':(BOOL,'1','setpoint','agent',['power_inlet'],('power.set','enabled')), |
| 'thermal.target_k':(TEMP,'K','setpoint','agent',['sample_peltier'],('thermal.set_temperature','temperature_k')), |
| 'thermal.block_k':(TEMP,'K','process_truth','evaluator',['sample_block'],None), |
| 'thermal.sample_k':(TEMP,'K','process_truth','evaluator',['sample_cup'],None), |
| 'thermal.indicated_temperature_k':(TEMP,'K','derived','agent',['thermopile','display_digits'],None), |
| 'lid.angle_rad':(ANGLE,'rad','scene','agent',['lid'],('lid.set_angle','angle_rad')), |
| 'latch.angle_rad':(ANGLE,'rad','scene','agent',['lever_lock'],('latch.set_angle','angle_rad')), |
| 'warmup.elapsed_s':(number('s',0),'s','derived','agent',['electronics'],None), |
| 'warmup.ready':(BOOL,'1','derived','agent',['electronics'],None), |
| 'method.mode':(MODE,'1','setpoint','agent',['display_digits'],None), |
| 'cycle.phase':(PHASE,'1','derived','agent',['display_digits'],None), |
| 'cycle.elapsed_s':(number('s',0),'s','derived','agent',['display_digits'],None), |
| 'equilibrium.stable':(BOOL,'1','derived','agent',['display_digits'],None), |
| 'water_activity.indicated':(NULL_AW,'1','derived','agent',['chilled_mirror','display_digits'],None), |
| 'dewpoint.indicated_k':({'anyOf':[number('K',200,323.15),{'type':'null'}]},'K','derived','agent',['chilled_mirror'],None), |
| 'calibration.offset_aw':(number('1',-.03,.03),'1','setpoint','agent',['chilled_mirror'],None), |
| 'isotherm.configured':(BOOL,'1','derived','agent',['display_digits'],None), |
| 'sample.loaded':(BOOL,'1','derived','agent',['sample_cup'],None), |
| 'sample.input_kg':(number('kg',0),'kg','process_truth','evaluator',['sample_cup'],None), |
| 'sample.retained_kg':(number('kg',0),'kg','process_truth','evaluator',['sample_cup'],None), |
| 'sample.removed_kg':(number('kg',0),'kg','process_truth','evaluator',['sample_cup'],None), |
| 'water.input_kg':(number('kg',0),'kg','process_truth','evaluator',['sample_cup'],None), |
| 'water.sample_kg':(number('kg',0),'kg','process_truth','evaluator',['sample_cup'],None), |
| 'water.headspace_kg':(number('kg',0),'kg','process_truth','evaluator',['sample_block'],None), |
| 'water.removed_kg':(number('kg',0),'kg','process_truth','evaluator',['sample_cup'],None), |
| 'water.ambient_in_kg':(number('kg',0),'kg','process_truth','evaluator',['sample_block'],None), |
| 'water.ambient_out_kg':(number('kg',0),'kg','process_truth','evaluator',['sample_block'],None), |
| } |
| |
| def _fmt_date(iso,fmt): |
| d=datetime.datetime.fromisoformat(iso);return f"{d:%m/%d/%y}" if fmt=='mm/dd/yy' else f"{d:%d/%m/%y}" |
| ASSET_VERSION='1.3.0' |
| ASSET_DIR=ROOT/'assets/expansion_batch04/t4_measure/aqualab_4te' |
| SERIAL='AL400000001' |
| LID_SERIAL='ALB00000001' |
| FIRMWARE='AS4 3.00.11' |
| CLOCK_EPOCH=datetime.datetime(2026,1,1,8,0,0) |
| MAX_RECORDS=8000 |
| SETTINGS={'temperature_unit':['C','F'],'date_format':['mm/dd/yy','dd/mm/yy'],'time_format':['12h','24h'],'language':['English'], |
| 'autosave':[True,False],'beeps':['four','continuous','none'],'print_mode':['off','on','detailed']} |
| SETTINGS_DEFAULT={'temperature_unit':'C','date_format':'mm/dd/yy','time_format':'12h','language':'English','autosave':True,'beeps':'four','print_mode':'off'} |
| ACCESS=['calibration','temperature','temp_eq','sensor','mode','date_time','region','password','autosave','beeps','delete'] |
| NAME={'type':'string','minLength':1,'maxLength':20};PASSWORD={'type':'string','minLength':1,'maxLength':16};LINE={'type':'string','maxLength':20} |
| RECORD=obj({'seq':number('1',1),'name':LINE,'water_activity':NULL_AW,'temperature_k':TEMP,'test_time_s':number('s',0),'user':TEXT,'datetime':TEXT, |
| 'sensor':TEXT,'moisture_dry_basis':NULL_NUM,'model':{'anyOf':[TEXT,{'type':'null'}]}}) |
| SETTINGS_SCHEMA=obj({k:({'type':'boolean'} if k=='autosave' else {'type':'string','enum':v}) for k,v in SETTINGS.items()},optional=tuple(SETTINGS)) |
| ACCESS_SCHEMA=obj({k:BOOL for k in ACCESS}) |
| USERS=obj({'admin_set':BOOL,'current':{'anyOf':[TEXT,{'type':'null'}]},'users':{'type':'array','maxItems':20,'items':obj({'name':TEXT,'access':ACCESS_SCHEMA})}}) |
| MODEL_NAME={'anyOf':[NAME,{'type':'null'}]} |
| FAULTS={'dew_point_sensor':('Dew point sensor failure',False),'crystal':('Crystal Failure. See Manual for options.',True), |
| 'contaminated_mirror':('Contaminated mirror.',False),'firmware':('Firmware is corrupted. See Manual for options.',False)} |
| FAULT={'anyOf':[{'type':'string','enum':list(FAULTS)},{'type':'null'}]} |
| DEVICE_CAPS={ |
| 'settings.configure':(obj({'settings':SETTINGS_SCHEMA}),obj({'settings':SETTINGS_SCHEMA}),['display_digits'],'设备设置（温度单位、日期格式、12/24小时、语言、自动保存、结束提示音、串口打印模式；aq p.34、p.36）：只改给出的项，断电保留','configuration','agent',{'settings':{'autosave':True}},['device.settings']), |
| 'clock.set_date':(obj({'year':number('1',2000,2099),'month':number('1',1,12),'day':number('1',1,31)}),obj({'datetime':TEXT}),['electronics'],'设定仪器日期（aq p.33 Date）；时刻不变，记录随每次读数保存','configuration','agent',{'year':2026,'month':3,'day':15},['device.datetime']), |
| 'clock.set_time':(obj({'hour':number('1',0,23),'minute':number('1',0,59)}),obj({'datetime':TEXT}),['electronics'],'设定仪器时刻（aq p.34 Time，秒归零）','configuration','agent',{'hour':9,'minute':30},['device.datetime']), |
| 'data.save':(obj({'name':LINE}),obj({'seq':number('1',1)}),['display_digits'],'读数结束后、下次测量前手动保存/注释最近读数（aq p.13、p.36）：已自动保存的读数改名并按当前产品模型更新含水率，否则新存一条','device_command','agent',{'name':'SAMPLE5'},['data.records','data.last_reading']), |
| 'data.delete_all':(obj({}),obj({'deleted':number('1',0)}),['electronics'],'删除全部已存读数（aq p.34；不能单条删除，删除不可恢复）','device_command','agent',{},['data.records','data.last_reading']), |
| 'beeper.silence':(obj({}),obj({'beeping':BOOL}),['electronics'],'AUDIO OFF：停止结束提示音（aq p.25 Table 2）','device_command','agent',{},['beeper.on']), |
| 'isotherm.select':(obj({'name':MODEL_NAME}),obj({'name':MODEL_NAME}),['display_digits'],'选择用于含水率的产品等温线模型（测量页UP/DOWN、%Moisture，aq p.7、p.33；null为不显示含水率）','configuration','agent',{'name':None},['isotherm.selected','isotherm.configured']), |
| 'isotherm.set_offset':(obj({'name':NAME,'offset_dry_basis':number('1',-1,1)}),obj({'name':TEXT,'offset_dry_basis':number('1',-1,1)}),['display_digits'],'模型含水率线性偏置（2019手册2.5.4 Edit与2.5.5 Defaults=0）：之后该模型的含水率加此偏置','configuration','agent',{'name':'demo','offset_dry_basis':0.},['isotherm.models']), |
| 'isotherm.copy':(obj({'source':NAME,'name':NAME,'offset_dry_basis':number('1',-1,1)}),obj({'name':TEXT}),['display_digits'],'以已有模型为底建立新模型并带偏置（2019手册2.5.4 New）','configuration','agent',{'source':'demo','name':'demo B','offset_dry_basis':0.},['isotherm.models']), |
| 'isotherm.delete':(obj({'name':NAME}),obj({'name':TEXT}),['display_digits'],'从仪器删除模型（2019手册2.5.6，不可恢复）；若正被选用则改为不显示含水率','configuration','agent',{'name':'demo'},['isotherm.models','isotherm.selected','isotherm.configured']), |
| 'users.set_admin_password':(obj({'password':PASSWORD}),obj({'admin_set':BOOL}),['electronics'],'设定或更改管理员密码（aq p.30-31；忘记后须送厂复位）','configuration','agent',{'password':'admin1'},['users.state']), |
| 'users.add':(obj({'name':NAME,'password':PASSWORD}),obj({'name':TEXT}),['electronics'],'管理员新增用户（User Setup，aq p.31；须先设管理员）','configuration','agent',{'name':'Jean Paul','password':'jp'},['users.state']), |
| 'users.set_password':(obj({'name':NAME,'password':PASSWORD}),obj({'name':TEXT}),['electronics'],'更改用户密码（User Setup > Password）','configuration','agent',{'name':'Jean Paul','password':'jp2'},['users.state']), |
| 'users.set_access':(obj({'name':NAME,'access':ACCESS_SCHEMA}),obj({'name':TEXT}),['electronics'],'用户的Access：逐项锁定配置选项（true=锁定；aq p.32）','configuration','agent',{'name':'Jean Paul','access':{k:False for k in ACCESS}},['users.state']), |
| 'users.delete':(obj({'name':NAME}),obj({'name':TEXT}),['electronics'],'删除用户','configuration','agent',{'name':'Jean Paul'},['users.state']), |
| 'users.login':(obj({'name':NAME,'password':PASSWORD}),obj({'current':TEXT}),['electronics'],'用户（或Admin）登录：之后读数记录该用户，其Access锁定的选项在面板上不可进入（登录流程手册未写，假设）','device_command','agent',{'name':'Admin','password':'admin1'},['users.state']), |
| 'fault.inject':(obj({'code':{'type':'string','enum':list(FAULTS)},'persistent':BOOL},optional=('persistent',)),obj({'fault':FAULT}),['electronics'], |
| '评测者：注入手册p.58 Table 6的故障信息（Dew point sensor failure、Crystal Failure、Contaminated mirror、Firmware is corrupted）：屏幕显示该信息，' |
| '按键无反应（电源开关与锁杆除外），进行中的读数取消，不能开始读数；Crystal Failure断电重启即清除（persistent=True时仍在），其余须维修或清洁镜面（fault.clear）', |
| 'simulation','evaluator',{'code':'crystal'},['device.fault','cycle.phase']), |
| 'fault.clear':(obj({}),obj({'fault':FAULT}),['electronics'],'评测者：排除注入的故障（代表Addium维修，或Contaminated mirror时按手册4.2清洁镜面与样品室）', |
| 'simulation','evaluator',{},['device.fault']), |
| 'users.logout':(obj({}),obj({'current':{'anyOf':[TEXT,{'type':'null'}]}}),['electronics'],'注销当前用户','device_command','agent',{},['users.state']), |
| } |
| DEVICE_SLOTS={ |
| 'device.settings':(SETTINGS_SCHEMA,'1','setpoint','agent',['display_digits'],None), |
| 'device.datetime':(TEXT,'1','derived','agent',['electronics'],None), |
| 'data.records':({'type':'array','maxItems':MAX_RECORDS,'items':RECORD},'1','derived','agent',['electronics'],None), |
| 'data.last_reading':({'anyOf':[RECORD,{'type':'null'}]},'1','derived','agent',['display_digits'],None), |
| 'beeper.on':(BOOL,'1','derived','agent',['electronics'],None), |
| 'serial.output':({'type':'array','maxItems':50,'items':TEXT},'1','derived','agent',['rs232_port'],None), |
| 'isotherm.models':({'type':'array','maxItems':64,'items':obj({'name':TEXT,'matrix_id':TEXT,'temperature_k':TEMP,'offset_dry_basis':number('1',-1,1)})},'1','derived','agent',['display_digits'],None), |
| 'isotherm.selected':(MODEL_NAME,'1','setpoint','agent',['display_digits'],None), |
| 'users.state':(USERS,'1','derived','agent',['electronics'],None), |
| 'device.fault':(FAULT,'1','derived','agent',['display_digits'],None), |
| } |
| SLOTS.update(DEVICE_SLOTS) |
| CAPS['acquisition.start'][7].extend(['data.last_reading','beeper.on']) |
| CAPS['isotherm.configure'][7].extend(['isotherm.models','isotherm.selected']) |
| DEVICE_PRE={'clock.set_date':('日期须存在（如无2月30日）；无测量进行',['cycle.phase']),'clock.set_time':('无测量进行',['cycle.phase']), |
| 'data.save':('有最近完成的读数且下一次测量尚未开始；存储未满8000条',['data.last_reading','data.records']), |
| 'isotherm.select':('模型在仪器上（null不选）',['isotherm.models']),'isotherm.set_offset':('模型在仪器上；无测量进行',['isotherm.models','cycle.phase']), |
| 'isotherm.copy':('源模型在仪器上、新名称未用；无测量进行',['isotherm.models','cycle.phase']),'isotherm.delete':('模型在仪器上；无测量进行',['isotherm.models','cycle.phase']), |
| 'users.add':('已设管理员密码；名称未用（Admin保留）',['users.state']),'users.set_password':('用户存在',['users.state']),'users.set_access':('用户存在',['users.state']), |
| 'users.delete':('用户存在',['users.state']),'users.login':('用户（或Admin）存在且密码正确',['users.state']), |
| 'settings.configure':('无测量进行',['cycle.phase']),'data.delete_all':('无测量进行',['cycle.phase']),'users.set_admin_password':('无测量进行',['cycle.phase']), |
| 'fault.inject':('评测者；任何时候（断电时开机后显示）',[]),'fault.clear':('评测者',['device.fault'])} |
| DEVICE_CAP_ERRORS={'clock.set_date':['BUSY'],'clock.set_time':['BUSY'],'data.save':['NO_READING','MEMORY_FULL'],'isotherm.select':['MODEL_NOT_FOUND'], |
| 'isotherm.set_offset':['MODEL_NOT_FOUND','BUSY'],'isotherm.copy':['MODEL_NOT_FOUND','NAME_EXISTS','BUSY'],'isotherm.delete':['MODEL_NOT_FOUND','BUSY'], |
| 'users.add':['ADMIN_REQUIRED','NAME_EXISTS','BUSY'],'users.set_password':['USER_NOT_FOUND','BUSY'],'users.set_access':['USER_NOT_FOUND','BUSY'], |
| 'users.delete':['USER_NOT_FOUND','BUSY'],'users.login':['USER_NOT_FOUND','WRONG_PASSWORD','BUSY'],'users.logout':[],'beeper.silence':[], |
| 'settings.configure':['BUSY'],'data.delete_all':['BUSY'],'users.set_admin_password':['BUSY'],'fault.inject':[],'fault.clear':[]} |
| DEVICE_ERRORS={'NO_READING':'没有可保存的最近读数（下一次测量已开始或尚未完成读数）','MEMORY_FULL':'已存8000条读数，存储已满','MODEL_NOT_FOUND':'仪器上没有该名称的模型', |
| 'NAME_EXISTS':'同名模型或用户已存在','ADMIN_REQUIRED':'须先设定管理员密码','USER_NOT_FOUND':'没有该用户','WRONG_PASSWORD':'密码不正确'} |
|
|
| from asset_runtime import _panel_ui |
| PANEL_PATH=ASSET_DIR/'panel_ui.json' |
| PANEL_SPEC=None if os.environ.get('AQUALAB_PANEL_BUILD')=='1' or not PANEL_PATH.is_file() else _panel_ui.load_spec(PANEL_PATH,capabilities=set(CAPS)|set(DEVICE_CAPS)) |
| PANEL_CAPS=_panel_ui.capability_definitions(PANEL_SPEC) if PANEL_SPEC else {} |
| PANEL_HOOKS={} |
| _PANELS=weakref.WeakKeyDictionary() |
| _PANEL_EFFECTS=list(dict.fromkeys(x for c in (_panel_ui.spec_capabilities(PANEL_SPEC) if PANEL_SPEC else []) for x in {**CAPS,**DEVICE_CAPS}[c][7])) |
| ALL_CAPS={**CAPS,**DEVICE_CAPS,**{k:(d['input_schema'],d['output_schema'],d['component_ids'],d['function_zh'],d['kind'],d['visibility'],d['example_arguments'], |
| [] if k in ('panel.capture','panel.frame') else _PANEL_EFFECTS) for k,d in PANEL_CAPS.items()}} |
|
|
|
|
| def psat(t): |
| c=t-273.15;return 610.94*math.exp(17.625*c/(243.04+c)) |
| def dewpoint(p): |
| x=math.log(max(p,1e-12)/610.94);return 273.15+243.04*x/(17.625-x) |
| class Aqualab4teRuntime: |
| def __init__(self,instance_id='aqualab4te_01'): |
| self.instance_id=instance_id;self.time_s=0.;self.revision=0;self.powered=False;self.warmup_s=0. |
| self.target_k=298.15;self.block_k=298.15;self.sample_k=298.15;self.lid_angle=0.;self.latch_angle=0. |
| self.mode='single';self.delta=.0005;self.temp_tolerance=.5;self.consecutive=1;self.offset=0.;self.isotherm=None |
| self.phase='idle';self.elapsed_s=0.;self.operation_id=None;self._operation_count=0;self.stable=False;self.indicated_aw=None;self.indicated_dew=None;self.history=[];self._stable_count=0 |
| self.templates=json.loads((ROOT/TEMPLATE_REL).read_text())['substances'];self.sample=None |
| self.input_kg=0.;self.removed_kg=0.;self.water_input=0.;self.water_removed=0.;self.sample_water=0.;self.sample_dry=0. |
| self.vapor=psat(298.15)*.5*20e-6*.01801528/(8.314462618*298.15);self.ambient_in=self.vapor;self.ambient_out=0. |
| self._principals={'__public_agent__':'agent'};self._requests={};self._owners={};self._caller=None |
| |
| self.settings=dict(SETTINGS_DEFAULT);self.clock_offset_s=0.;self.records=[];self._seq=0;self.last_reading=None;self.beep_until=-1.;self.serial_out=[] |
| self.models={};self.model_selected=None;self.admin_password=None;self.users={};self.current_user=None;self.power_epoch=0;self._was_stable=False |
| self.panel_capture_dir=None;self.fault=None |
| @property |
| def panel(self): |
| """The front panel of this instance (kept outside the instance dict, which tests compare as the runtime state).""" |
| if self not in _PANELS: |
| _PANELS[self]=_panel_ui.PanelUI(PANEL_SPEC,self,hooks=PANEL_HOOKS) |
| return _PANELS[self] |
| def register_principal(self,principal_id,visibility='agent'): |
| if visibility not in ('agent','evaluator','debug'):raise ActionRejected('INVALID_ARGUMENT') |
| if principal_id in self._principals:raise ActionRejected('REQUEST_CONFLICT') |
| self._principals[principal_id]=visibility |
| def session(self,principal_id='__public_agent__'): |
| if principal_id not in self._principals:raise ActionRejected('ACCESS_DENIED') |
| return Aqualab4teSession(self,principal_id) |
| def describe(self):return self.session().describe(instance_id=self.instance_id) |
| def _values(self): |
| return {'power.enabled':self.powered,'thermal.target_k':self.target_k,'thermal.block_k':self.block_k,'thermal.sample_k':self.sample_k,'thermal.indicated_temperature_k':round(self.sample_k-273.15,2)+273.15,'lid.angle_rad':self.lid_angle,'latch.angle_rad':self.latch_angle,'warmup.elapsed_s':self.warmup_s,'warmup.ready':self.warmup_s>=900,'method.mode':self.mode,'cycle.phase':self.phase,'cycle.elapsed_s':self.elapsed_s,'equilibrium.stable':self.stable,'water_activity.indicated':self.indicated_aw,'dewpoint.indicated_k':self.indicated_dew,'calibration.offset_aw':self.offset,'isotherm.configured':self.isotherm is not None,'sample.loaded':self.sample is not None,'sample.input_kg':self.input_kg,'sample.retained_kg':self.sample_water+self.sample_dry,'sample.removed_kg':self.removed_kg,'water.input_kg':self.water_input,'water.sample_kg':self.sample_water,'water.headspace_kg':self.vapor,'water.removed_kg':self.water_removed,'water.ambient_in_kg':self.ambient_in,'water.ambient_out_kg':self.ambient_out, |
| 'device.settings':dict(self.settings),'device.datetime':self._now().isoformat(timespec='seconds'),'data.records':copy.deepcopy(self.records), |
| 'data.last_reading':copy.deepcopy(self.last_reading),'beeper.on':self.time_s<self.beep_until,'serial.output':list(self.serial_out), |
| 'isotherm.models':[dict(name=n,matrix_id=m['matrix_id'],temperature_k=m['temperature_k'],offset_dry_basis=m['offset']) for n,m in self.models.items()], |
| 'isotherm.selected':self.model_selected, |
| 'users.state':dict(admin_set=self.admin_password is not None,current=self.current_user,users=[dict(name=n,access=dict(u['access'])) for n,u in self.users.items()]), |
| 'device.fault':self.fault['code'] if self.fault and self.powered else None} |
| def read(self,visibility='agent'):return copy.deepcopy({k:v for k,v in self._values().items() if SLOTS[k][3]=='agent' or visibility in ('evaluator','debug')}) |
| def debug_snapshot(self):return dict(state=self.read('evaluator'),sample=copy.deepcopy(self.sample)) |
| def _measure(self): |
| moisture=None |
| if self.sample and self.isotherm and self.indicated_aw is not None and self.isotherm['matrix_id']==self.sample['matrix_id'] and abs(self.sample_k-self.isotherm['temperature_k'])<.05: |
| for a,b in zip(self.isotherm['points'],self.isotherm['points'][1:]): |
| if a['water_activity']<=self.indicated_aw<=b['water_activity']: |
| moisture=a['moisture_dry_basis']+(b['moisture_dry_basis']-a['moisture_dry_basis'])*(self.indicated_aw-a['water_activity'])/(b['water_activity']-a['water_activity'])+self.isotherm.get('offset',0.);break |
| quality='unavailable' if self.indicated_aw is None else 'warmup_incomplete' if self.warmup_s<900 else 'suspect_volatile' if self.sample and self.sample['volatile_interference'] else 'estimated' |
| return dict(water_activity=self.indicated_aw,temperature_k=self._values()['thermal.indicated_temperature_k'],equilibrated=self.stable,phase=self.phase,quality=quality,evidence='derived_measured_reference_with_synthetic_dynamics',template_source=TEMPLATE_REL,moisture_dry_basis=moisture,moisture_evidence='user_supplied_isotherm' if moisture is not None else 'unavailable') |
| def invoke(self,capability,**a): |
| if capability in PANEL_CAPS:return self._panel_command(capability,a) |
| if capability in DEVICE_CAPS:return self._device(capability,a) |
| if capability not in CAPS:raise ActionRejected('UNKNOWN_CAPABILITY') |
| validate(CAPS[capability][0],a) |
| if self.phase=='running' and capability not in ('power.set','latch.set_angle','acquisition.stop','water_activity.measure','calibration.verify'):raise ActionRejected('BUSY') |
| if capability=='power.set': |
| if not self.powered and a['enabled']: |
| self.warmup_s=0.;self.power_epoch+=1 |
| if self.fault and not self.fault['persistent']:self.fault=None |
| self.powered=a['enabled'] |
| if not self.powered: |
| self.stable=False |
| if self.phase=='running':self.phase='cancelled' |
| r=dict(a) |
| elif capability=='thermal.set_temperature': |
| if abs((a['temperature_k']-273.15)*10-round((a['temperature_k']-273.15)*10))>1e-7:raise ActionRejected('INVALID_ARGUMENT') |
| self.target_k=a['temperature_k'];self.indicated_aw=None;self.stable=False;r=dict(a) |
| elif capability=='lid.set_angle': |
| if a['angle_rad']>1e-4 and self.latch_angle>.1:raise ActionRejected('PRECONDITION_FAILED') |
| self.lid_angle=a['angle_rad'];self.stable=False;r=dict(a) |
| elif capability=='latch.set_angle': |
| if a['angle_rad']>.1 and self.lid_angle>1e-4:raise ActionRejected('PRECONDITION_FAILED') |
| self.latch_angle=a['angle_rad'] |
| if self.latch_angle<1.4: |
| self.stable=False |
| if self.phase=='running':self.phase='cancelled' |
| r=dict(a) |
| elif capability=='sample.configure': |
| if not a['matrix_id'].strip():raise ActionRejected('INVALID_ARGUMENT') |
| row=self.templates.get(a['substance_id']);index=a['record_index'] |
| if self.lid_angle<1.4 or self.sample or not row or not row['runtime_eligible'] or index!=int(index) or index>=len(row['records']):raise ActionRejected('PRECONDITION_FAILED') |
| record=row['records'][int(index)];self.sample=copy.deepcopy(a);self.sample['reference']=copy.deepcopy(record) |
| self.sample_water=a['mass_kg']*record['water_mass_fraction'];self.sample_dry=a['mass_kg']-self.sample_water;self.input_kg+=a['mass_kg'];self.water_input+=self.sample_water;self.sample_k=a['initial_temperature_k'];self.indicated_aw=None;self.indicated_dew=None;self.stable=False;r={'configured':True} |
| elif capability=='sample.unload': |
| if self.lid_angle<1.4 or not self.sample:raise ActionRejected('PRECONDITION_FAILED') |
| self.removed_kg+=self.sample_water+self.sample_dry;self.water_removed+=self.sample_water;self.sample=None;self.sample_water=0.;self.sample_dry=0.;self.indicated_aw=None;self.indicated_dew=None;self.stable=False;r={'unloaded':True} |
| elif capability=='method.configure': |
| n=a['consecutive_readings'];mode=a['mode'];delta=a['stability_delta'] |
| if n!=int(n) or (mode=='custom' and (n<2 or delta<.0005)) or (mode=='low_emitting' and delta>.003) or (mode=='iso18787' and abs(delta-.0003)>1e-12):raise ActionRejected('INVALID_ARGUMENT') |
| self.mode=mode;self.delta=delta;self.temp_tolerance=a['temperature_tolerance_k'];self.consecutive=int(n);self.stable=False;r={'configured':True} |
| elif capability=='calibration.configure': |
| if not a['source'].strip():raise ActionRejected('INVALID_ARGUMENT') |
| self.offset=a['offset_aw'];self.indicated_aw=None;self.stable=False;r={'offset_aw':self.offset} |
| elif capability=='calibration.verify': |
| if not self.powered or self.indicated_aw is None or not self.stable or self.warmup_s<900:raise ActionRejected('PRECONDITION_FAILED') |
| delta=self.indicated_aw-a['reference_aw'];return {'deviation_aw':delta,'within_vendor_tolerance':abs(delta)<=.003} |
| elif capability=='isotherm.configure': |
| p=a['points'] |
| if not a['source'].strip() or not a['matrix_id'].strip() or any(b['water_activity']<=x['water_activity'] or b['moisture_dry_basis']<x['moisture_dry_basis'] for x,b in zip(p,p[1:])):raise ActionRejected('INVALID_ARGUMENT') |
| self.isotherm=dict(copy.deepcopy(a),offset=0.);self.models[a['matrix_id']]=self.isotherm;self.model_selected=a['matrix_id'];r={'configured':True} |
| elif capability=='acquisition.start': |
| if not self.powered or self.fault or not self.sample or self.lid_angle>1e-4 or self.latch_angle<1.4 or abs(self.target_k-self.sample['reference']['temperature_k'])>.050001:raise ActionRejected('PRECONDITION_FAILED') |
| self._operation_count+=1;self.operation_id=f'{self.instance_id}:aw:{self._operation_count}';self.phase='running';self.elapsed_s=0.;self.history=[];self._stable_count=0;self.stable=False;self.indicated_aw=None;r={'phase':'running','operation_id':self.operation_id} |
| self.last_reading=None;self._was_stable=False;self.beep_until=-1.;self.raw_aw=None |
| elif capability=='acquisition.stop': |
| if self.phase=='running':self.phase='cancelled' |
| r={'phase':self.phase} |
| else:return self._measure() |
| self.revision+=1;return copy.deepcopy(r) |
| |
| def _now(self): |
| return CLOCK_EPOCH+datetime.timedelta(seconds=round(self.clock_offset_s+self.time_s)) |
| def _reading_done(self): |
| """A finished reading (aq p.8): results with the SAVE icon, the end beeps, autosave (aq p.36) and the serial print (2019 manual Table 3).""" |
| m=self._measure();t=self._now() |
| rec=dict(seq=0,name='',water_activity=self.indicated_aw,temperature_k=m['temperature_k'],test_time_s=self.elapsed_s,user=self.current_user or '', |
| datetime=t.isoformat(timespec='seconds'),sensor='Dew Point',moisture_dry_basis=m['moisture_dry_basis'],model=self.model_selected) |
| if self.settings['autosave'] and len(self.records)<MAX_RECORDS: |
| self._seq+=1;rec['seq']=self._seq;self.records.append(copy.deepcopy(rec)) |
| self.last_reading=rec |
| self.beep_until={'four':self.time_s+2.,'continuous':math.inf}.get(self.settings['beeps'],-1.) |
| if self.settings['print_mode']!='off': |
| line=f"{self.elapsed_s/60:.1f} {m['temperature_k']-273.15:.1f} {self.indicated_aw:.4f}" |
| if self.settings['print_mode']=='detailed':line=f"{t:%d-%m-%y} {t:%H:%M} {SERIAL} "+line |
| self.serial_out=(self.serial_out+[line])[-50:] |
| def _device(self,cap,a): |
| validate(DEVICE_CAPS[cap][0],a) |
| if self.phase=='running' and cap not in ('isotherm.select','beeper.silence','data.save','users.logout','fault.inject','fault.clear'):raise ActionRejected('BUSY') |
| if cap=='fault.inject': |
| self.fault=dict(code=a['code'],persistent=bool(a.get('persistent',False)) or not FAULTS[a['code']][1]);self.stable=False |
| if self.phase=='running':self.phase='cancelled' |
| r={'fault':a['code']} |
| elif cap=='fault.clear': |
| self.fault=None;r={'fault':None} |
| elif cap=='settings.configure': |
| self.settings.update(a['settings']);r=dict(settings=dict(self.settings)) |
| elif cap in ('clock.set_date','clock.set_time'): |
| if any(v!=int(v) for v in a.values()):raise ActionRejected('INVALID_ARGUMENT') |
| now=self._now() |
| try:new=now.replace(year=int(a['year']),month=int(a['month']),day=int(a['day'])) if cap=='clock.set_date' else now.replace(hour=int(a['hour']),minute=int(a['minute']),second=0) |
| except ValueError:raise ActionRejected('INVALID_ARGUMENT') from None |
| self.clock_offset_s+=(new-now).total_seconds();r={'datetime':self._now().isoformat(timespec='seconds')} |
| elif cap=='data.save': |
| rec=self.last_reading |
| if rec is None:raise ActionRejected('NO_READING') |
| if not rec['seq'] and len(self.records)>=MAX_RECORDS:raise ActionRejected('MEMORY_FULL') |
| m=self._measure();rec.update(name=a['name'],model=self.model_selected,moisture_dry_basis=m['moisture_dry_basis']) |
| if rec['seq']:self.records=[copy.deepcopy(rec) if x['seq']==rec['seq'] else x for x in self.records] |
| else:self._seq+=1;rec['seq']=self._seq;self.records.append(copy.deepcopy(rec)) |
| r={'seq':rec['seq']} |
| elif cap=='data.delete_all': |
| r={'deleted':len(self.records)};self.records=[] |
| if self.last_reading:self.last_reading['seq']=0 |
| elif cap=='beeper.silence': |
| self.beep_until=-1.;r={'beeping':False} |
| elif cap in ('isotherm.select','isotherm.set_offset','isotherm.copy','isotherm.delete'): |
| name=a.get('source',a['name']) if cap=='isotherm.copy' else a['name'] |
| if name is not None and name not in self.models:raise ActionRejected('MODEL_NOT_FOUND') |
| if cap=='isotherm.select':self.model_selected=name |
| elif cap=='isotherm.set_offset':self.models[name]['offset']=a['offset_dry_basis'] |
| elif cap=='isotherm.copy': |
| if a['name'] in self.models:raise ActionRejected('NAME_EXISTS') |
| self.models[a['name']]=dict(copy.deepcopy(self.models[name]),offset=a['offset_dry_basis']) |
| else: |
| del self.models[name] |
| if self.model_selected==name:self.model_selected=None |
| self.isotherm=self.models.get(self.model_selected) |
| r={'name':self.model_selected} if cap=='isotherm.select' else dict(a) if cap=='isotherm.set_offset' else {'name':a['name']} |
| elif cap=='users.set_admin_password': |
| self.admin_password=a['password'];r={'admin_set':True} |
| elif cap=='users.login': |
| pw=self.admin_password if a['name']=='Admin' else self.users.get(a['name'],{}).get('password') |
| if pw is None:raise ActionRejected('USER_NOT_FOUND') |
| if pw!=a['password']:raise ActionRejected('WRONG_PASSWORD') |
| self.current_user=a['name'];r={'current':a['name']} |
| elif cap=='users.logout': |
| self.current_user=None;r={'current':None} |
| else: |
| name=a['name'] |
| if cap=='users.add': |
| if self.admin_password is None:raise ActionRejected('ADMIN_REQUIRED') |
| if name=='Admin' or name in self.users:raise ActionRejected('NAME_EXISTS') |
| self.users[name]=dict(password=a['password'],access={k:False for k in ACCESS}) |
| elif name not in self.users:raise ActionRejected('USER_NOT_FOUND') |
| elif cap=='users.set_password':self.users[name]['password']=a['password'] |
| elif cap=='users.set_access':self.users[name]['access']=dict(a['access']) |
| else: |
| del self.users[name] |
| if self.current_user==name:self.current_user=None |
| r={'name':name} |
| self.revision+=1;return copy.deepcopy(r) |
| |
| def panel_read(self): |
| """What the instrument firmware sees: the agent slots plus its own sensors and formatted texts (clock, data list, model list).""" |
| out=self.read('agent');t=self._now();st=self.settings |
| hm=f"{t:%H:%M}" if st['time_format']=='24h' else f"{(t.hour%12) or 12}:{t:%M}{'AM' if t.hour<12 else 'PM'}" |
| date=f"{t:%m/%d/%y}" if st['date_format']=='mm/dd/yy' else f"{t:%d/%m/%y}" |
| names=list(self.models);cyc=[None]+names;i=cyc.index(self.model_selected) if self.model_selected in cyc else 0 |
| def line(r): |
| d=datetime.datetime.fromisoformat(r['datetime']) |
| dd=f"{d:%m/%d}" if st['date_format']=='mm/dd/yy' else f"{d:%d/%m}" |
| tt=f"{d:%H:%M}" if st['time_format']=='24h' else f"{(d.hour%12) or 12}:{d:%M}{'AM' if d.hour<12 else 'PM'}" |
| return f"{dd},{tt},{'-' if r['water_activity'] is None else format(r['water_activity'],'.4f')}" |
| user=self.users.get(self.current_user) if self.current_user not in (None,'Admin') else None |
| dew=self.indicated_dew if self.phase=='running' and self.indicated_dew is not None else self.block_k |
| out.update({'host.powered':self.powered,'host.power_epoch':self.power_epoch,'host.time_text':hm,'host.date_text':date, |
| 'host.date_long':f"{t:%b} {t.day:02d}, {t.year}",'host.clock':dict(year=t.year,month=t.month,day=t.day,hour=t.hour,minute=t.minute), |
| 'host.sealed':self.lid_angle<1e-4 and self.latch_angle>=1.4,'host.running':self.phase=='running', |
| 'host.completed':self.last_reading is not None and self.phase!='running','host.raw_aw':getattr(self,'raw_aw',None), |
| 'host.delta_t':round(self.sample_k-self.block_k,2),'host.hot':self.phase=='running' and self.sample_k-self.block_k>4., |
| 'host.lid_k':round(self.block_k,2),'host.base_k':round(self.block_k,2),'host.sample_k':round(self.sample_k,2),'host.mirror_k':round(dew,2), |
| 'host.optical_mv':1745. if self.powered else 0.,'host.moisture':self._measure()['moisture_dry_basis'], |
| 'host.model_next':cyc[(i+1)%len(cyc)],'host.model_prev':cyc[(i-1)%len(cyc)], |
| 'host.records_view':[dict(seq=r['seq'],line=line(r),date=_fmt_date(r['datetime'],st['date_format']),time=line(r).split(',')[1],index=i+1) |
| for i,r in enumerate(self.records)][::-1],'host.record_count':len(self.records), |
| 'host.record_first':self.records[0]['seq'] if self.records else 0,'host.record_last':self.records[-1]['seq'] if self.records else 0, |
| 'host.users_login':['Admin']+list(self.users),'host.users_exist':bool(self.users), |
| 'host.locked':[k for k,v in user['access'].items() if v] if user else [],'host.serial':SERIAL,'host.lid_serial':LID_SERIAL,'host.firmware':FIRMWARE, |
| 'host.method':dict(mode=self.mode,delta=self.delta,tolerance=self.temp_tolerance,consecutive=self.consecutive),'host.calibration_offset':self.offset}) |
| return out |
| def panel_invoke(self,capability_id,arguments): |
| try: |
| validate(ALL_CAPS[capability_id][0],arguments) |
| if self._caller is not None:Aqualab4teSession(self,self._caller)._guard(capability_id,arguments) |
| return self.invoke(capability_id,**arguments) |
| except ActionRejected as exc:raise _panel_ui.PanelRejected(str(exc)) from None |
| def panel_time(self):return self.time_s |
| def _panel_command(self,k,a): |
| validate(ALL_CAPS[k][0],a) |
| if k=='panel.frame':return dict(frame=self.panel.frame()) |
| if k=='panel.capture': |
| data,w,h=self.panel.png_bytes(a['display_id']);sha=hashlib.sha256(data).hexdigest() |
| d=Path(self.panel_capture_dir) if self.panel_capture_dir else Path(tempfile.gettempdir())/'chemistry_sim_panel'/self.instance_id |
| d.mkdir(parents=True,exist_ok=True);path=d/f"{a['display_id']}_{sha[:16]}.png" |
| if not path.exists():path.write_bytes(data) |
| return dict(display_id=a['display_id'],time_s=self.time_s,image=dict(path=str(path),format='png',width=w,height=h,sha256=sha)) |
| try: |
| ok=self.panel.press(a['input_id'],float(a.get('duration_s',.1))) if k=='panel.press' else self.panel.switch(a['input_id'],a['position']) |
| except _panel_ui.PanelError:raise ActionRejected('INVALID_ARGUMENT') from None |
| self.revision+=1;return dict(accepted=bool(ok)) |
| def step(self,dt_s): |
| if isinstance(dt_s,bool) or not isinstance(dt_s,(int,float)) or not math.isfinite(dt_s) or dt_s<=0:raise ValueError('finite positive dt_s required') |
| left=float(dt_s) |
| while left>1e-10: |
| active=self.phase=='running';h=min(left,1.) |
| if active:h=min(h,(math.floor(self.elapsed_s/10+1e-8)+1)*10-self.elapsed_s) |
| if self.powered:self.warmup_s+=h |
| target=self.target_k if self.powered else 298.15;self.block_k=target+(self.block_k-target)*math.exp(-h/25.);self.sample_k=self.block_k+(self.sample_k-self.block_k)*math.exp(-h/35.) |
| closed=self.lid_angle<1e-4 and self.latch_angle>=1.4 |
| if self.sample and closed: |
| aw=self.sample['reference']['value'];eq=aw*psat(self.sample_k)*20e-6*.01801528/(8.314462618*self.sample_k);transfer=(eq-self.vapor)*(1-math.exp(-h/self.sample['equilibration_tau_s'])) |
| transfer=max(-self.vapor,min(self.sample_water,transfer));self.sample_water-=transfer;self.vapor+=transfer |
| elif not closed: |
| eq=.5*psat(self.sample_k)*20e-6*.01801528/(8.314462618*self.sample_k);transfer=(eq-self.vapor)*(1-math.exp(-h/5.));self.vapor+=transfer |
| if transfer>=0:self.ambient_in+=transfer |
| else:self.ambient_out-=transfer |
| if active: |
| self.elapsed_s+=h;p=self.vapor*8.314462618*self.sample_k/(20e-6*.01801528);true_aw=p/psat(self.sample_k) |
| indicated=round(true_aw+self.offset+(.005 if self.sample['volatile_interference'] else 0.),4);self.indicated_aw=indicated if .03<=indicated<=1 else None;self.raw_aw=indicated;self.indicated_dew=round(dewpoint(p)-273.15,2)+273.15 |
| if abs(self.elapsed_s/10-round(self.elapsed_s/10))<1e-7: |
| self.history.append((self.elapsed_s,indicated));self.history=self.history[-7:] |
| ref=(self.history[-7] if len(self.history)>=7 else None) if self.mode=='iso18787' else self.history[-2] if len(self.history)>=2 else None |
| stable=self.elapsed_s>=60 and ref is not None and abs(self.history[-1][1]-ref[1])<=self.delta and abs(self.sample_k-self.block_k)<=self.temp_tolerance and self.indicated_aw is not None |
| self._stable_count=self._stable_count+1 if stable else 0;self.stable=self._stable_count>=self.consecutive |
| if self.stable and self.mode!='continuous':self.phase='succeeded' |
| if self.stable and not self._was_stable:self._reading_done() |
| self._was_stable=self.stable |
| self.time_s+=h;left-=h |
| self.revision+=1;return self.read('evaluator') |
| class Aqualab4teSession: |
| """Host registers principals; public calls have no visibility override.""" |
| 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,i): |
| if i!=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=export_aqualab_4te_contract_metadata();meta['capabilities'].update(export_panel_contract_metadata()) |
| return dict(protocol_version=PROTOCOL_VERSION,asset_type_id=ASSET_TYPE_ID,asset_version=ASSET_VERSION, |
| capabilities={k:v for k,v in meta['capabilities'].items() if v['visibility']=='agent' or self._role!='agent'}, |
| state_slots={k:v for k,v in meta['state_slots'].items() if v['visibility']=='agent' or self._role!='agent'}) |
|
|
| def read(self,*,instance_id,state_ids=None): |
| self._target(instance_id); h=self._host; vals=h.read(self._role); ids=list(vals) 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 vals for k in ids): raise ActionRejected('ACCESS_DENIED') |
| return dict(status='succeeded',instance_id=instance_id,state_revision=h.revision,clock={'domain':'simulation','time_s':h.time_s}, |
| observations={k:dict(value=copy.deepcopy(vals[k]),unit=SLOTS[k][1],quality='unavailable' if vals[k] is None else ('estimated' if SLOTS[k][2]=='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): |
| try: |
| return self._invoke(instance_id=instance_id,capability_id=capability_id,arguments=arguments,request_id=request_id) |
| except ActionRejected as exc: |
| return dict(protocol_version=PROTOCOL_VERSION,instance_id=instance_id,request_id=request_id,operation_id=None, |
| status='rejected',state_revision=self._host.revision,clock={'domain':'simulation','time_s':self._host.time_s}, |
| result={},observations={},error=dict(code=str(exc),message=str(exc),retryable=False,side_effects='none')) |
|
|
| def _invoke(self,*,instance_id,capability_id,arguments,request_id): |
| self._target(instance_id); h=self._host |
| if not isinstance(capability_id,str) or capability_id not in ALL_CAPS: raise ActionRejected('UNKNOWN_CAPABILITY') |
| if self._role=='agent' and ALL_CAPS[capability_id][5]!='agent': raise ActionRejected('ACCESS_DENIED') |
| if not isinstance(request_id,str) or not request_id: raise ActionRejected('INVALID_ARGUMENT') |
| validate(ALL_CAPS[capability_id][0],arguments) |
| key=(self._principal,instance_id,request_id); digest=json.dumps([capability_id,arguments],sort_keys=True,allow_nan=False) |
| if key in h._requests: |
| old,result=h._requests[key] |
| if old!=digest: raise ActionRejected('REQUEST_CONFLICT') |
| return copy.deepcopy(result) |
| before=h.operation_id |
| self._guard(capability_id,arguments); h._caller=self._principal |
| try: result=h.invoke(capability_id,**arguments) |
| finally: h._caller=None |
| op=result.get('operation_id') |
| if op: h._owners[op]=self._principal |
| elif capability_id in PANEL_CAPS and h.operation_id and h.operation_id!=before: h._owners[h.operation_id]=self._principal |
| response=dict(protocol_version=PROTOCOL_VERSION,instance_id=instance_id,request_id=request_id,operation_id=op, |
| status='accepted' if op else 'succeeded',state_revision=h.revision,clock={'domain':'simulation','time_s':h.time_s},result=result,observations={},error=None) |
| h._requests[key]=(digest,copy.deepcopy(response)); return response |
|
|
| def _guard(self,capability_id,arguments): |
| """An agent may not stop another agent's running reading (direct call, or the panel CANCEL key); unowned readings and the evaluator |
| are not restricted; the chamber lever is mechanical and the rear power switch is a hard switch (lead clarification 10-19): neither is |
| guarded, switching off cancels the reading as on a power loss.""" |
| h=self._host |
| if self._role!='agent' or capability_id not in _CONTROL_GUARDED or h.phase!='running': return |
| if h._owners.get(h.operation_id) not in (None,self._principal): raise ActionRejected('ACCESS_DENIED') |
|
|
| def write(self,*,instance_id,state_id,value,request_id): |
| self._target(instance_id) |
| if state_id not in SLOTS or not SLOTS[state_id][5]: raise ActionRejected('ACCESS_DENIED') |
| cap,arg=SLOTS[state_id][5] |
| return self.invoke(instance_id=instance_id,capability_id=cap,arguments={arg:value},request_id=request_id) |
|
|
| def poll(self,operation_id): |
| h=self._host |
| if operation_id!=h.operation_id or h._owners.get(operation_id)!=self._principal: raise ActionRejected('ACCESS_DENIED') |
| return dict(operation_id=operation_id,status=h.phase,result=h._measure()) |
|
|
| def cancel(self,operation_id,request_id): |
| self.poll(operation_id) |
| response=self.invoke(instance_id=self._host.instance_id,capability_id='acquisition.stop',arguments={},request_id=request_id) |
| return dict(operation_id=operation_id,status=self._host.phase,result=response['result']) |
|
|
| _CONTROL_GUARDED={'acquisition.stop'} |
|
|
| def export_aqualab_4te_contract_metadata(): |
| caps={}; slots={} |
| for key,(schema,unit,origin,visibility,components,write) in SLOTS.items(): |
| slots[key]=dict(component_ids=components,value_schema=copy.deepcopy(schema),unit=unit,reference_conditions=None, |
| meaning_zh=None,origin=origin,visibility=visibility,access='read_write' if write else 'read_only', |
| read_binding=dict(backend='host',artifact_id='runtime',accessor=f'Aqualab4teSession.read(state_ids=[{key!r}])'), |
| write_via=dict(capability_id=write[0],argument=write[1],fixed_arguments={}) if write else None, |
| sampling=dict(mode='instant',time_domain='simulation',window_description=None),source_ids=['simulation_assumption']) |
| for key,(inp,out,components,meaning,kind,vis,example,effects) in {**CAPS,**DEVICE_CAPS}.items(): |
| async_=key=='acquisition.start'; pre=[] |
| conditions={ |
| 'acquisition.start':('供电、闭盖锁紧、已装样，目标温度匹配实测记录',['power.enabled','lid.angle_rad','latch.angle_rad','sample.loaded','thermal.target_k'],'powered and lid<=1e-4 and latch>=1.4 and loaded and abs(target-reference_T)<=0.050001'), |
| 'sample.configure':('受信任宿主、开盖、空杯、记录可用',['lid.angle_rad','sample.loaded'],'lid>=1.4 and empty and eligible and integral record index'), |
| 'sample.unload':('受信任宿主、开盖且有样',['lid.angle_rad','sample.loaded'],'lid>=1.4 and loaded'), |
| 'lid.set_angle':('无采集且锁杆已释放才能开盖',['cycle.phase','latch.angle_rad'],'not running and (angle<=1e-4 or latch<=0.1)'), |
| 'latch.set_angle':('只有盖闭时可锁；释放取消采集',['lid.angle_rad'],'angle<=0.1 or lid<=1e-4'), |
| 'calibration.verify':('已供电预热15分钟并有平衡读数',['power.enabled','warmup.ready','equilibrium.stable'],'powered and warmup>=900 and stable and indicated is not None')} |
| if key in conditions: |
| description,states,check=conditions[key] |
| pre=[dict(description_zh=description,state_ids=states,enforced_by='runtime',check=check)] |
| if key in DEVICE_PRE: |
| pre=[dict(description_zh=DEVICE_PRE[key][0],state_ids=DEVICE_PRE[key][1],enforced_by='runtime',check='Aqualab4teRuntime._device')] |
| caps[key]=dict(function_zh=meaning,kind=kind,visibility=vis,component_ids=components,availability='implemented', |
| input_schema=copy.deepcopy(inp),output_schema=copy.deepcopy(out), |
| implementation=dict(process='implemented',scene='absent',robot='absent',hardware='absent',host='implemented'), |
| binding=dict(backend='host',artifact_id='runtime',entrypoint='asset_runtime.aqualab_4te.Aqualab4teSession.invoke',invocation=f'session.invoke(instance_id="aqualab4te_01", capability_id={key!r}, arguments={example!r}, request_id="unique")'), |
| preconditions=pre,state_effects=[dict(state_id=k,timing='immediate',description_zh=meaning) for k in effects],observes=[], |
| model_effects=dict(mode='none',description_zh='此处仅声明运行过程；几何联动由宿主另行绑定验证。',binding_ids=[]), |
| execution=dict(mode='asynchronous' if async_ else 'synchronous',time_domain='simulation', |
| completion_criterion='cycle.phase=succeeded；取消保留热状态和水分转移；连续模式须显式停止' if async_ else '设定写入或观测返回；不推进物理时钟', |
| completion_state_ids=['cycle.phase'] if async_ else effects,timeout_s=None,cancellation='supported' if async_ else 'unsupported', |
| retry='same_request_id',resources=['target_instance','principal_request_cache'],partial_failure_zh='拒绝不改过程；取消/断电不回滚已经发生的水分转移和热过程。去重只在当前进程内存有效。'), |
| errors=[dict(code=e,meaning_zh=e,side_effects='none') for e in ['UNKNOWN_INSTANCE','UNKNOWN_CAPABILITY','ACCESS_DENIED','INVALID_ARGUMENT','PRECONDITION_FAILED','BUSY','REQUEST_CONFLICT']] |
| +[dict(code=e,meaning_zh=DEVICE_ERRORS[e],side_effects='none') for e in DEVICE_CAP_ERRORS.get(key,[]) if e in DEVICE_ERRORS], |
| example_arguments=copy.deepcopy(example),verification=[],limitations=['工程代理，无真实硬件连接；进程内过滤不能替代文件和进程部署隔离。']+(DEVICE_LIMITS if key in DEVICE_CAPS else []), |
| source_ids=['manufacturer_primary','simulation_assumption'] if key not in DEVICE_CAPS else ['manufacturer_manual','simulation_assumption']+(['manufacturer_manual_2019'] if key.startswith('isotherm.') else [])) |
| mechanism=dict(component_ids=['sample_cup','sample_block','chilled_mirror','thermopile','sample_peltier','mirror_peltier','chamber_fan'], |
| state_ids=['thermal.block_k','thermal.sample_k','water.input_kg','water.sample_kg','water.headspace_kg','water.removed_kg','water.ambient_in_kg','water.ambient_out_kg'], |
| meaning_zh='实测二元水溶液活度参考点驱动头空间传质、露点与温控代理，闭合水质量账本',implementation='lumped', |
| equations=['aw=p_vapor/p_sat(T_sample)', 'p_sat=610.94*exp(17.625*T_C/(243.04+T_C)) Pa (Magnus engineering approximation)', |
| 'm_eq=aw_reference*p_sat*V_headspace*M_water/(R*T); dm=(m_eq-m_vapor)*(1-exp(-dt/tau))', |
| 'water_input+ambient_in=sample_water+headspace_water+removed_water+ambient_out', |
| 'open chamber vapor relaxes toward assumed ambient RH=0.5; direct open-sample evaporation omitted', |
| 'moisture=piecewise linear supplied product isotherm only at matching matrix/temperature, no extrapolation'], |
| parameters={'headspace_volume':dict(value=20e-6,unit='m^3',meaning_zh='未知真实体积的传质代理',evidence='assumption',source_ids=['simulation_assumption'],uncertainty=None)}, |
| source_ids=['aw_templates','simulation_assumption'],limitations=['平衡时间、热滞后和Magnus露点均engineering_assumption，不保证厂家准确度。','传质中以原始溶液活度近似不变；未求组成变化后的活度及开盖样品蒸发。','未实现真实凝结液膜、光路/冷镜伺服、挥发物补偿或完整厂家算法；ISO 18787模式按一分钟内读数变化≤0.0003判定（代理）。','没有实测产品吸附等温线时含水率不可用；公开水溶液平衡点不是产品吸附等温线。']) |
| _ann.annotate_export('aqualab_4te',caps,slots,{'water_activity':mechanism},inputs={}) |
| return dict(asset_type_id=ASSET_TYPE_ID,catalog_id=CATALOG_ID,capabilities=caps,state_slots=slots,mechanisms={'water_activity':mechanism}) |
|
|
|
|
| DEVICE_LIMITS=['设备层（1.1.0）：设置、时钟、数据存储、提示音、串口打印、产品模型与用户均为仪器内的非易失状态（断电保留）；时钟为仿真时间加偏置（t=0时为2026-01-01 08:00，假设）；' |
| '串口打印只记录仪器发出的行（serial.output），无真实串口设备；AquaLink/SKALA的模型下载与数据备份没有连接（需USB/云），删除前的备份提醒因此总是出现。', |
| '用户与Access：手册写了管理员密码、用户增删与逐项锁定，未写登录流程；本资产在有用户时开机先选用户并输密码（假设），锁定的选项在面板上不可进入，直接命令不受锁定限制（假设）。', |
| '%Moisture校准（New/Edit/Delete/Defaults）按2019版Series 4手册2.5.4–2.5.6实现为模型含水率线性偏置；2025版手册把模型偏置移到SKALA，仪器上的该菜单保留。', |
| '故障（1.2.0）：手册p.58 Table 6的四条故障信息由评测者fault.inject注入（默认无）：屏幕显示该信息（版面为假设），按键无反应（电源开关与锁杆除外），进行中的读数取消、不能开始读数；Crystal Failure断电重启清除（persistent=True时仍在），Dew point sensor failure与Firmware is corrupted须维修，Contaminated mirror须按4.2清洁镜面（清洁本身未建模），均由fault.clear代表；冷镜、晶振与固件的内部原因不建模。'] |
| PANEL_LIMITS=['前面板层（panel.*）：按panel_ui.json（AQUALAB 4手册18280-6页码证据）实现128×64点阵屏的三个标签页（Measurement、Configuration、Data）与各配置屏、四个方向键、' |
| '三个随图标变化的圆键、样品室锁杆（READ开始读数、OPEN中断）与后部电源开关；每个面板动作都调用本运行层的同名能力（没有第二份仪器逻辑）；手势不推进仿真时钟。', |
| '圆键图标按手册Table 2写为文字（ENTER、CANCEL、MENU、SAVE、OK、AUDIO）；测量页ENTER在样品室已锁紧时重新开始读数、读数进行中只显示CANCEL、提示音进行中左键为AUDIO OFF，均为手册未写的假设，见panel_ui.json。', |
| '面板不含3D联动：屏幕纹理（render()）与键关节触发手势属于后续Matterix步骤；Matterix现有的“左圆键=开始测量”映射是场景捷径，与手册（锁杆到READ开始）不同。', |
| '调用者规则（1.2.0）：面板手势以会话调用者身份执行：锁杆到READ或ENTER开始的读数属于该调用者（可poll/cancel）；另一agent不能用CANCEL键或直接调用acquisition.stop结束他人的读数（被拒、状态不变）；样品室锁杆是机械件、后部电源开关是硬开关（负责人澄清10-19），都不受此限，关断电源时读数按断电取消。', |
| '一致性清查（1.2.1）：另一agent被拒的CANCEL键在键图标上方一行显示“Started by other user” 2 s（文字为假设：真实仪器没有调用者概念）。'] |
|
|
|
|
| def export_panel_contract_metadata(): |
| """Contract entries of the panel capabilities: a gesture changes what the commands it calls change.""" |
| out={} |
| for k,d in PANEL_CAPS.items(): |
| query=k in ('panel.capture','panel.frame') |
| c={key:copy.deepcopy(d[key]) for key in ['input_schema','output_schema','component_ids','function_zh','kind','visibility','example_arguments']} |
| c.update(availability='implemented',implementation=dict(process='implemented',scene='absent',robot='absent',hardware='absent',host='implemented'), |
| binding=dict(backend='host',artifact_id='runtime',entrypoint='asset_runtime.aqualab_4te.Aqualab4teSession.invoke', |
| invocation=f'session.invoke(instance_id="aqualab4te_01", capability_id={k!r}, arguments={d["example_arguments"]!r}, request_id="unique")'), |
| preconditions=[dict(description_zh='断电时屏幕暗、按键无反应（只有电源开关起作用）；被调用能力的前提同样适用（被拒时屏幕显示仪器的提示，手势不被接受）' |
| if not query else '无（关机时为暗屏）',state_ids=['power.enabled'],enforced_by='runtime',check='Aqualab4teRuntime.invoke')], |
| state_effects=[] if query else [dict(state_id=x,timing='immediate',description_zh='手势调用的能力所写的状态（导航本身不改状态槽）') for x in _PANEL_EFFECTS], |
| observes=[],model_effects=dict(mode='none',description_zh='面板层只改界面状态与被调用能力的状态，屏幕画面由panel.capture渲染',binding_ids=[]), |
| execution=dict(mode='synchronous',time_domain='simulation',completion_criterion='立即返回当前画面' if query else '手势瞬时完成（不推进仿真时钟）：结果只说明是否被仪器接受，屏幕须用panel.capture查看', |
| completion_state_ids=[],timeout_s=None,cancellation='unsupported',retry='same_request_id',resources=['target_instance'], |
| partial_failure_zh='被拒的手势不改变运行层状态（只显示仪器的提示）'), |
| errors=[dict(code=e,meaning_zh={'INVALID_ARGUMENT':'未知输入件或显示件、手势与输入件不符','ACCESS_DENIED':'评测者专用','REQUEST_CONFLICT':'同一request_id用于不同请求', |
| 'UNKNOWN_INSTANCE':'实例ID不存在'}[e],side_effects='none') |
| for e in ['INVALID_ARGUMENT','REQUEST_CONFLICT','UNKNOWN_INSTANCE']+(['ACCESS_DENIED'] if d['visibility']!='agent' else [])], |
| verification=[],limitations=list(PANEL_LIMITS),source_ids=['manufacturer_manual','manufacturer_manual_2019','simulation_assumption']) |
| out[k]=c |
| return out |
|
|
|
|
