pyhostvm 0.41.0__py3-none-win_amd64.whl

pyhostvm/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.41.0" 

pyhostvm/tj010.ptl

@@ -0,0 +1,243 @@
+namespace tj010
+{
+    struct UnitModel
+    {
+        int NumberofNumerator               /* 分子系数的个数，optional，可为空 */;
+        int NumberofDenominator             /* 分母系数的个数，optional，可为空 */;
+        double NumeratorCoefficient[~]      /* 分子系数  optional，可为空 */;
+        double DenominatorCoefficient[~]    /* 分母系数  optional，可为空 */;
+        int UnitStepRespLength              /* 阶跃序列长度 */;
+        double UnitStepResponse[~]          /* 阶跃响应序列 */;
+        int delay                           /* 纯滞后 */;
+        double StableGain                   /* 稳态增益 对于积分环节，为稳态增益斜率 */;
+        int IntegralMark                    /* 积分标志1：积分环节；0：非积分环节 */;
+    };
+
+    struct InputVariable
+    {
+        int MVType = 1                  /* default: 1  0: DV; 1: MV */; 
+        int Status = 1                  /* default: 1   0：检测出现故障；1：正常 */; 
+        int ControlStatus               /* 控制状态 default: 0;  0: OFF；1：ON; 2: FeedForward */; 
+        int KeyVariable                 /* 关键变量（没用）     default: 0  0: NO; 1: YES */; 
+        double HiLimit = 100.0          /* 上限 */; 
+        double LoLimit                  /* 下限 */; 
+        double PosSpeedLim = 10.0       /* 2022-01-16新增 MV正速率限制  */; 
+        double NegSpeedLim = 10.0       /* 2022-01-16新增 MV负速率限制 */; 
+        double _IncrConstraint = 10.0   /* 2022-01-16删除   增量约束(SpeedLimit)  */; 
+        double IRVExpect = 0.0          /* IRV期望值    default: 0 */; 
+        double LinearWeight = 0.0       /* 线性权重    default: 0 */; 
+        double QuadraticWeight = 0.0    /* 二次权重    default: 0 */; 
+        double SoftHiLimit = 0.0        /* 缓冲区上间距    default: 0 */; 
+        double SoftLoLimit = 0.0        /* 缓冲区下间距    default: 0 */; 
+        double PRIWeight = 0.0          /* 优先权重（没用）    default: 0 */; 
+        double IncrementWeight = 1.0    /* 增量权重    default: 1 */; 
+        double ErrorWeight = 0.0        /* 误差权重    default: 0 */; 
+        int IntBlock = 15               /* default: 15 */; 
+        double DVPrd[~]                 /* default: [], v0.28.1新增, 未来DV的预测数组(不包含当前值！) */
+                                        /* self.DVPrd = [] 表示未来的DV预测使用了默认方式：DVprd = [uk] */;
+
+        /* 以下属性不记入TaiJiMPC4.0的ojp工程文件 */
+        /* 即：仅允许用脚本修改，作为临时变量，脚本修改结果不存入.ojp的工程文件。*/
+        int SetNm = -1                  /* 修改MV的控制时域（非负整数），请慎重！*/
+                                        /* 默认: -1，表示启动控制器(Start Control)时/模型更换时使用内部默认值。*/
+                                        /* 注意：若要使用内部默认的控制时域，需要：(1)控制器重启(Stop control -> Start control)  或 在线更换模型, (2)SetNm<0 */;
+        double EngHI                    /*注意内部要设置默认值正无穷*/;
+        double EngLO                    /*注意内部要设置默认值负无穷*/;
+		double OperatingRange = 1.0     /*默认: 1.0 */;
+    };
+
+    struct OutputVariable
+    {
+        int Status = 1                  /* 状态  default: 1  0：检测出现故障；1：正常 */;
+        int ControlStatus = 0           /* 控制状态 0(default): OFF; 1: ON; 2: PRD only;  */;
+        int KeyVariable = 0             /* 关键变量（没用）     default: 0  0: NO; 1: YES */;
+        int ControlType = 2             /* 控制类型     1：设定值控制；2：区间控制(StickyRange); 3: 区间控制(FreeRange) */;
+        double SetPoint = 0.0           /* 设定值 (FTSPBias is included!) */;
+        double HiRange = 100.0          /* 区间上限 */;
+        double LoRange = 0.0            /* 区间下限 */;
+        double ClsLpRsponseTime = 2.0   /* 闭环响应时间（单位：分钟） */;
+        double IRVExpect = 0.0          /* IRV期望值    default: 0 */;
+        double LinearWeight = 0.0       /* 线性权重    default: 0 */;
+        double QuadraticWeight = 0.0    /* 二次权重    default: 0 */;
+        double SoftHiLimit = 0.0        /* 缓冲区上间距default: 0即为优化区域上限间距 */;
+        double SoftLoLimit = 0.0        /* 缓冲区下间距default: 0即为优化区域下限间距 */;
+        double PRIWeight = 1.0          /* 优先权重  default: 1 */;
+        int Priority = 1                /* 优先级 */;
+        double ErrorWeight = 1.0        /* 误差权重    default: 1 */;
+        double IncrementWeight = 100.0  /* CV 增量权重 2021-09-04新增 */;
+        int DistAdaptiveSwt = 0         /* 扰动自适应的开关; 0: OFF, 1: ON. */;
+        int DistModelOrder = 0          /* 干扰模型的阶次 */;
+        int DistPredHorizon = 6         /* 使用干扰模型进行输出预测的长度 */;
+        int DistAdaptiveMode = 2        /* 干扰模型的形式 {0:'', 1:'c0', 2:'c0c1', 3:'c0c1c2'} */;
+        int DistAdaptiveDataLen = 3     /* 估计干扰模型的数据长度 */;
+        double DistForgettingFactor = 1.0    /* 估计干扰模型的遗忘因子 */;
+        double DistFilterCoef = 3.0     /* 合并输出滤波系数 */;
+        int FTSPType = 0                /* 0: None, 1:协调控制负荷斜坡, 2:协调控制滑压曲线, 3: 架空稳态层 */;
+        double FTSPRate = 0.0           /* Slope Tag in Tai-Ji MPC */;
+        double FTSPEnd = 0.0            /* "End SP Tag" (FTSPBias is not included!) or "X Axis End Tag" in Tai-Ji MPC */;
+        int FTSPNum = 0                 /* X Axis Cur. Tag in Tai-Ji MPC */;
+        astring FTSPXY                  /* strFXY in Tai-Ji MPC  */;
+        double FTSPTau = 0.0            /* Filter in Tai-Ji MPC */;
+        double FTSPBias = 0.0           /* Delta Tag in Tai-Ji MPC */;
+        int FTSPHzn = 0                 /* Pred Horizon in Tai-Ji MPC */;
+
+        /* 以下属性不记入TaiJiMPC4.0的ojp工程文件 */
+        /* 即：仅允许用脚本修改，作为临时变量，脚本修改结果不存入.ojp的工程文件。 */
+        double ErrWtRngFactor = 0.02    /* 2023-03-05 仅在FreeRange条件下起作用。  */
+                                        /* 区间内CV误差权重因子(ErrorWeightInRange = ErrWtRngFactor*ErrorWeight)  */;
+        double IncWtRngFactor = 0.02    /* 2023-03-05 仅在FreeRange条件下起作用。  */
+                                        /* 区间内CV增量权重因子(IncrementWeightInRange = IncWtRngFactor*IncrementWeight) */;
+        int IntBlock = 200              /* 修改CV的间隔块数（线性间隔），请慎重！ */;
+        int SetNp = -1                  /* 修改CV的预测时域（非负整数），请慎重！ */
+                                        /* 默认: -1，表示启动控制器(Start Control)时/模型更换时使用内部默认值。 */
+                                        /* 注意：若要使用内部默认的预测时域，需要：(1)控制器重启(Stop control -> Start control) 或 在线更换模型, (2)SetNp<0 */;
+        double EngHI                    /*注意内部要设置默认值正无穷*/;
+        double EngLO                    /*注意内部要设置默认值负无穷*/;
+        double SPFilterTau              /*设定值滤波器时间常数*/;
+        double SPFilterAlpha            /*设定值滤波器超前系数*/;
+		double OperatingRange = 1.0     /*默认: 1.0 */;
+    };
+
+    [zpy_ignore]
+    struct SetupModelInput
+    {
+        int InputNum;
+        int OutputNum;
+        struct UnitModel ControlModel[~];
+        struct UnitModel PlantModel[~];
+        int ControlModelFlag;
+        int PlantModelFlag;
+        int ControlInterval;
+        astring InputTagName[~];
+        astring OutputTagName[~];
+    };
+
+    [zpy_ignore]
+    struct SetupModelOutput
+    /*where come from?*/
+    {
+        int iOutput;
+        astring szOutput;
+        float fOutput;
+        double dOutput;
+        struct UnitModel uModel;
+    };
+
+    [function]
+    struct ControllerSetupModel
+    {
+        [tuple] struct SetupModelInput Input;
+    };
+    
+    [zpy_ignore]
+    struct ProcessVarInitInput
+    {
+        struct InputVariable InputVar[~]    /* typInputVariable结构的一维数组，长度InputNum  */;
+        struct OutputVariable OutputVar[~]  /* typOutputVariable结构的一维数组 长度OutputNum */;
+    };
+
+    [function]
+    struct ControllerProcessVarInit
+    {
+        [tuple] struct ProcessVarInitInput Input;
+    };
+
+    [zpy_ignore]
+    struct ModifyMutiOutputVariablesInput
+    {
+        int VarIndex[~];
+        struct OutputVariable OutputVar[~];
+    };
+
+    [function]
+    struct ControllerModifyMutiOutputVariables
+    {
+        [tuple] struct ModifyMutiOutputVariablesInput Input;
+    };
+
+    [zpy_ignore]
+    struct ModifyMutiInputVariablesInput
+    {
+        int VarIndex[~];
+        struct InputVariable InputVar[~];
+    };
+
+    [function]
+    struct ControllerModifyMutiInputVariables
+    {
+        [tuple] struct ModifyMutiInputVariablesInput Input;
+    };
+
+    [zpy_ignore]
+    struct ControllerCalculationInput
+    {
+        double InputValue[~]    /* 输入值数组，长度InputNum */;
+        double OutputValue[~]   /* 输出值数组，长度OutputNum */;
+        int m;
+    };
+
+    [zpy_ignore]
+    struct ControllerCalculationOutput
+    {
+        double InputPredVal[~]         /* 返回值，m*InputNum * 1, MV、DV预测值 */;
+        double InputSSVal[~]           /* 返回值，InputNum * 1, MV、DV稳态值 */;
+        int InputPredHorizon[~]     /* 返回值，InputNum * 1, MV、DV模型时域 */;
+        double OutputPredVal[~]        /* 返回值，m*OutputNum* 1, CV预测值 */;
+        double OutputSSVal[~]          /* 返回值，OutputNum* 1, CV稳态值 */;
+        int OutputPredHorizon[~]    /* 返回值，OutputNum* 1, CV模型时域 */;
+        double InputErrPct[~]          /* 返回值，InputNum* 1, MV、DV误差百分比 */;
+        double InputIncPct[~]          /* 返回值，InputNum* 1, MV、DV增量百分比 */;
+        double OutputErrPct[~]         /* 返回值，OutputNum* 1, CV误差百分比 */;
+        double OutputIncPct[~]         /* 返回值，OutputNum* 1, CV增量百分比 */;
+        double InputMaxDeltaPrd[~]     /* 返回值，InputNum* 1, MX,DV最大预测变化量 */;
+        double OutputMaxDeltaPrd[~]    /* 返回值，OutputNum* 1, CV最大预测变化量 */;
+    };
+
+    [function]
+    struct ControllerCalculation
+    {
+        [tuple] struct ControllerCalculationInput Input;
+        struct ControllerCalculationOutput Output;
+    };
+
+    [zpy_ignore]
+    struct SetupLPVModelInput
+    {
+        int model_id                        /* 模型ID */;
+        double working_point                /* 工作点 */;
+        int InputNum                        /* 输入变量总数 */;        
+        int OutputNum                       /* 输出变量总数 */;
+        struct UnitModel ControlModel[~]    /* 控制模型 typModel结构的二维数组 */
+                                            /* 维数：（int输出变量总数, int输入变量总数），用于模型预测 */;
+        astring InputTagName[~]             /* 输入变量名称数组 */;
+        astring OutputTagName[~]            /* 输出变量名称数组 */;
+    };
+
+    [function]
+    struct ControllerSetupLPVModel
+    {
+        [tuple] struct SetupLPVModelInput Input;
+    };
+
+    [function]
+    struct ControllerPlantRecursion
+    {
+        double Output[~]         /* 返回值，Output double数组 */;
+    };
+
+    [zpy_ignore]
+    struct ControllerGetLPVModelStatusOutput
+    {
+        int LPV_SW                      /* 返回值，LPV模型开关，0表示关闭，1表示开启  */;
+        double working_value			/* 返回值，工作点变量的当前值 */;
+        int model_id[~]					/* 返回值，LPV模型ID */;
+        double working_point[~]         /* 返回值，ID对应模型的工作点列表 */;
+        double current_weight[~]        /* 返回值，ID对应模型的权重列表 */;
+    };
+
+    [function]
+    struct ControllerGetLPVModelStatus
+    {
+        struct ControllerGetLPVModelStatusOutput Output;
+    };
+}

pyhostvm/tj010_start.py

@@ -0,0 +1,250 @@
+import sys, os, logging, zce, gc
+from datetime import datetime
+from typing import List, Tuple
+from tj010.tj007pyInterface import ControllerInterface
+from tj010.tj007pyInterface.DLL007data import *
+
+def SetupLogger():
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)  # 最低 level
+
+    # 确保 log 目录存在
+    log_dir = "log"
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+
+    # 文件 handler（所有级别）
+    log_filename = os.path.join(log_dir, f"tj010_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log")
+    file_handler = logging.FileHandler(log_filename, encoding='utf-8')
+    file_handler.setLevel(logging.INFO)
+
+    # stdout handler（DEBUG、INFO）
+    stdout_handler = logging.StreamHandler(sys.stdout)
+    stdout_handler.setLevel(logging.DEBUG)
+    stdout_handler.addFilter(lambda record: record.levelno < logging.WARNING)
+
+    # stderr handler（WARNING, ERROR, CRITICAL）
+    stderr_handler = logging.StreamHandler(sys.stderr)
+    stderr_handler.setLevel(logging.WARNING)
+
+    # 格式（可选）
+    formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
+    file_handler.setFormatter(formatter)
+    stdout_handler.setFormatter(formatter)
+    stderr_handler.setFormatter(formatter)
+
+    # 清空默认 handler（很重要）
+    logger.handlers.clear()
+    logging.basicConfig(level=logging.DEBUG)
+    # 添加 handler
+    logger.addHandler(file_handler)
+    logger.addHandler(stdout_handler)
+    logger.addHandler(stderr_handler)
+
+def ControllerCreate():
+    # 实例化MPC控制器
+    logging.debug("ControllerCreate")
+    mpc1 = ControllerInterface()
+    mpc1.ControllerFlagInitialization(path = os.getcwd())
+    return zce.registe_object(mpc1)
+
+def ControllerStop(mpc1):
+    logging.debug("ControllerStop")
+    #todo unregiste_object
+    mpc1.StopControl()
+    zce.unregiste_object(mpc1)
+
+def ControllerCreateSimple():
+    # 实例化MPC控制器
+    logging.debug("ControllerCreateSimple")
+    mpc1 = ControllerInterface()
+    mpc1.ControllerFlagInitialization(path = os.getcwd())
+    return mpc1
+
+def ControllerStopSimple(mpc1):
+    logging.debug("ControllerStopSimple")
+    mpc1.StopControl()
+
+def ControllerFlagInitialization(mpc1, path, interval):
+    logging.debug(f"ControllerFlagInitialization {path}, {interval}")
+    mpc1.ControllerFlagInitialization(path, interval)
+
+def ControllerSaveMPCObj(mpc1):
+    logging.debug("ControllerSaveMPCObj")
+    mpc1.save_mpcobj()    
+
+def ControllerSetupModel(mpc1,
+                         InputNum: int,    # 输入变量总数
+                        OutputNum: int,   # 输出变量总数
+                        ControlModel: List[UnitModel],  # 控制模型 typModel结构的二维数组
+                                                        # 维数：（int输出变量总数, int输入变量总数），用于模型预测
+                        PlantModel: List[UnitModel],    #工厂模型 typModel结构的二维数组
+                                                        # 维数：（int输出变量总数, int输入变量总数），用于仿真时的工厂模型递推。
+                        ControlModelFlag: int,  # 控制模型标志    
+                                                # 为1，表示模型预测时使用的阶跃响应序列由传递函数计算得来
+                                                # 为0，表示模型预测直接使用客户程序给定的阶跃响应序列
+                        PlantModelFlag: int,    # 工厂模型标志    
+                                                # 为1，表示仿真时工厂模型递推使用的阶跃响应序列由传递函数计算得来
+                                                # 为0，表示仿真时工厂模型递推直接使用客户程序给定的阶跃响应序列
+                        ControlInterval: int,   # 控制周期, 要与客户程序生成阶跃响应序列时使用的控制周期一致
+                        InputTagName: List[str],    # 输入输出变量名称数组，分别存放于InputTagName和OutputTagName
+                        OutputTagName: List[str],
+                        **kargs                
+                    ):
+    print(f"ControllerSetupModel, {InputNum}, {OutputNum}, {ControlModelFlag}, {PlantModelFlag}, {ControlInterval}")
+    mpc1.SetupModel(InputNum, OutputNum, ControlModel, PlantModel, 
+                    ControlModelFlag, PlantModelFlag, ControlInterval, InputTagName, OutputTagName, **kargs)
+
+def ControllerProcessVarInit(mpc1,
+                             InputVar: List[InputVariable],     # typInputVariable结构的一维数组，长度InputNum 
+                             OutputVar: List[OutputVariable],   # typOutputVariable结构的一维数组 长度OutputNum
+                             **kargs  
+                             ) -> None:
+    logging.debug(f"ControllerProcessVarInit, {InputVar}, {OutputVar}")
+    mpc1.ProcessVariableInitialization(InputVar, OutputVar)
+
+def ControllerModifyMutiInputVariables(mpc1, VarIndexList: list[int], InputVarList: list[InputVariable]) -> None:
+    logging.debug(f"ControllerModifyMutiInputVariables, {VarIndexList}, {InputVarList}")
+    mpc1.ModifyMutiInputVariables(VarIndexList, InputVarList)
+
+def ControllerModifyMutiOutputVariables(mpc1, VarIndexList: list[int], OutputVarList: list[OutputVariable]) -> None:
+    logging.debug(f"ControllerModifyMutiOutputVariables, {VarIndexList}, {OutputVarList}")
+    mpc1.ModifyMutiOutputVariables(VarIndexList, OutputVarList)
+
+def ControllerModifyGainFactor(mpc1, gains):
+    logging.debug(f"ControllerModifyGainFactor, {gains}")
+    mpc1.ModifyGainFactor(gains)
+    
+def ControllerCalculation(mpc1, 
+                          InputValue: List[float],         # 输入变量值，一维数组 长度InputNum
+                          OutputValue: List[float],        # 输出变量值，一维数组 长度OutputNum
+                          m: int = 20):
+    # 计算
+    logging.debug(f"ControllerCalculation, {InputValue}, {OutputValue}, {m}")
+    ret = mpc1.ControllerCalculation(InputValue, OutputValue, m)
+    logging.info(f"ControllerCalculation, after calculation, {OutputValue}")
+    return ret
+
+def ControllerModelPrediction(mpc1,
+                    InputValue: List[float],     # 输入变量值，一维数组 长度InputNum
+                    OutputValue: List[float]     # 输出变量值，一维数组 长度OutputNum
+                    ) -> None:
+    logging.debug(f"ControllerModelPrediction, {InputValue}, {OutputValue}")
+    mpc1.ModelPrediction(InputValue, OutputValue)
+    logging.info(f"ControllerModelPrediction, after prediction, {OutputValue}")
+
+def ControllerPlantRecursion(mpc1,
+                    InputValue: List[float],     # 输入变量值，一维数组 长度InputNum
+                    OutputValue: List[float]     # 输出变量值，一维数组 长度OutputNum
+                    ) -> List[float]:     # 输出变量值，一维数组 长度OutputNum 
+    logging.debug(f"ControllerPlantRecursion, {InputValue}, {OutputValue}")
+    return mpc1.PlantRecursion(InputValue, OutputValue)
+
+
+def ControllerSetupLPVModel(mpc1, 
+                    model_id: int,                  # 模型ID
+                    working_point: float,           # 工作点
+                    InputNum: int,                  # 输入变量总数        
+                    OutputNum: int,                 # 输出变量总数
+                    ControlModel: List[UnitModel],  # 控制模型 typModel结构的二维数组
+                                                    # 维数：（int输出变量总数, int输入变量总数），用于模型预测
+                    InputTagName: List[str],        # 输入变量名称数组
+                    OutputTagName: List[str],       # 输出变量名称数组
+                    **kargs                         # 
+                    ) -> None:
+    logging.debug(f"ControllerSetupLPVModel, {model_id}, {working_point}, {InputNum}, {OutputNum}, {ControlModel}, {InputTagName}, {OutputTagName}")
+    mpc1.SetupLPVModel(model_id, working_point, InputNum, OutputNum, ControlModel, InputTagName, OutputTagName, **kargs)
+
+def ControllerDeleteLPVModel(mpc1, 
+                    model_id: int    # 根据id删除工作点模型
+                    ) -> None:
+    logging.debug(f"ControllerDeleteLPVModel, {model_id}")
+    mpc1.DeleteLPVModel(model_id)
+
+def ControllerUseBasicMPCModel(mpc1) -> None:
+    mpc1.use_basic_MPCmodel()
+
+def ControllerUseInterpLPVModel(mpc1,
+                        working_value: float  # 工作点变量的值
+                        ) -> None:
+    mpc1.use_interp_LPVmodel(working_value)
+
+def ControllerGetAttr(mpc1, attr_name: str):
+    attr_value = getattr(mpc1, attr_name)
+    logging.debug(f"ControllerGetAttr, {attr_name}, {attr_value}")
+    return attr_value
+
+def ControllerSetAttrs(mpc1, attr_dict: dict):
+    logging.debug(f"ControllerSetAttrs, {attr_dict}")
+    
+    for attr_name, attr_value in attr_dict.items():
+        if hasattr(mpc1, attr_name):
+            setattr(mpc1, attr_name, attr_value)
+            logging.debug(f"Set {attr_name} to {attr_value} in {mpc1}")
+        else:
+            logging.error(f"Attribute {attr_name} does not exist in {mpc1}")
+
+def ControllerSetupParameters(mpc1, OptionDict):
+    logging.debug(f"ControllerSetupParameters, {OptionDict}")
+    # 控制器总开关
+    mpc1.EconomicOptFlag = OptionDict["EconomicOptFlag"]
+    mpc1.DistPredSW = OptionDict["DistPredSW"]
+    print("ControllerSetupParameters", mpc1.EconomicOptFlag, mpc1.DistPredSW)
+
+def ControllerGetLPVModelStatus(mpc1, dummyInput) -> dict:
+    status = mpc1.getLPVmodelStatus()
+    logging.debug(f"ControllerGetLPVModelStatus, {status}")
+    return (status["LPV_SW"], status["working_value"], status["model_id"], status["working_point"], status["current_weight"])
+
+def ControllerGetErrorCode(mpc1, dummyInput) -> int:
+    err_code = mpc1.get_error_code()
+    logging.debug(f"ControllerGetErrorCode, {err_code}")
+    return err_code
+
+def ControllerGarbageCollect(mpc1):
+    logging.debug("ControllerGarbageCollect")
+    gc.collect()  # 强制垃圾回收，释放内存
+
+def _ControllerPlot(mpc1):
+    print("ControllerPlot")
+    import tj010.mpcplot as mpcplot
+    mpcplot.ShowCurrentParam(mpc1)
+    
+    # 仿真结果绘图
+    import importlib.util
+
+    def is_matplotlib_installed():
+        matplotlib_spec = importlib.util.find_spec("matplotlib")
+        return matplotlib_spec is not None
+
+    if is_matplotlib_installed():
+        import matplotlib.pyplot as plt
+        mpcplot.PlotControllerData(mpc1)
+        mpcplot.PlotCurrentModelStp(mpc1)
+        plt.show()
+
+def RegistMeta():
+    
+    zce.registe_class(UnitModel)
+
+    zce.registe_class(InputVariable)
+
+    zce.registe_class(OutputVariable)
+
+    zce.registe_meta(os.path.join(os.path.dirname(__file__), 'tj010.ptl'))
+
+def RegistRpcCallableFunctions():
+    import inspect
+
+    def get_functions():
+        return [(name, obj) for name, obj in globals().items() if inspect.isfunction(obj)]
+
+    # 当前模块中的所有函数
+    current_module_functions = get_functions()
+    for name, obj in current_module_functions:
+        if (name.startswith("Controller")):
+            zce.registe_callable(name, obj)
+
+#SetupLogger()
+#RegistMeta()
+#RegistRpcCallableFunctions()

pyhostvm-0.41.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: pyhostvm
+Version: 0.41.0
+Summary: Python support library for HostVM (win_amd64)
+Home-page: https://github.com/ymwang78/IndustryDataHub
+Author: Yongming Wang
+Author-email: wangym@gmail.com
+License: MIT
+Project-URL: Bug Reports, https://github.com/ymwang78/IndustryDataHub/issues
+Project-URL: Source, https://github.com/ymwang78/IndustryDataHub
+Project-URL: Documentation, https://github.com/ymwang78/IndustryDataHub/wiki
+Keywords: industrial automation,data communication,OPC,modbus,multi-platform
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: Communications
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pywin32>=305
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+* Python Support Library For HostVM
+
+1. tj010_start.py: wrapper for tj010

pyhostvm-0.41.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pyhostvm/__init__.py,sha256=6q5bwtbTdl36qwvX_CLtBrgbItFM1W4rXFFwgJPM2wY,23
+pyhostvm/tj010.ptl,sha256=-zDwg1XMpFSxCZvJ5gmhnCQ9laIeLFikNA0mA0gGT1M,12687
+pyhostvm/tj010_start.py,sha256=T8AjjWs3xt6C0HOmNtVj1Y-KiXaF9DgCyycRCPEQuRc,11601
+pyhostvm-0.41.0.dist-info/METADATA,sha256=H4dYHqA93hiVDV5NNA9CR8dilaFyHiK3C6r6KXuSfU0,1377
+pyhostvm-0.41.0.dist-info/WHEEL,sha256=QR8DNjG6Lr6bNErJWJgF4dP2dJ2N7NpY-BWly1OvcTM,97
+pyhostvm-0.41.0.dist-info/top_level.txt,sha256=ezoe9Mak4XeZpyEctSnFWH2aC13pUdF0EpAKuaZsUxk,9
+pyhostvm-0.41.0.dist-info/RECORD,,

pyhostvm-0.41.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-win_amd64
+

pyhostvm-0.41.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyhostvm