langjie-m-play 0.0.21 → 0.0.23

package/domain/AtsInfo.d.ts

@@ -4,4 +4,5 @@ export interface AtsInfo {
     atsParams: Record<string, any>;
     started: boolean;
     atsFile: string;
+    ctrlTag: string;
 }

package/domain/AtsLoadResponse.d.ts

@@ -3,4 +3,6 @@ export interface AtsLoadResponse<K extends string, V> {
     atsParam: Record<K, V>;
     atsButtonList: string[];
     atsFile: string;
+    ctrlTag: string;
+    atsName: string;
 }

package/domain/VtcMsgTypeConstant.d.ts

@@ -0,0 +1,46 @@
+export declare const LAUNCH_STEP = 256;
+export declare const LAUNCH_ABORTED = 4096;
+export declare const LAUNCH_OK = 8192;
+export declare const CLOSE_STEP = 16384;
+export declare const CLOSE_OK = 32768;
+export declare const RUN_MSG = 512;
+export declare const RUN_EVENT = 768;
+export declare const RUN_EVENT_TOUCH = 784;
+export declare const RUN_WARNING = 1024;
+export declare const RUN_DEBUG = 1280;
+export declare const ATS_LOADING = 1536;
+export declare const ATS_LOAD_ABORTED = 1552;
+export declare const ATS_LOAD_OK = 1568;
+export declare const ATS_STARTING = 1584;
+export declare const ATS_STARTED = 1616;
+export declare const ATS_BREAK = 1632;
+export declare const ATS_CONTINUE = 1648;
+export declare const ATS_CATCH_CONTROLLER = 1664;
+export declare const ATS_RELEASE_CONTROLLER = 1680;
+export declare const ATS_TERMINATING = 1696;
+export declare const ATS_ACTION = 1792;
+export declare const ATS_ABORTED = 2048;
+export declare const ATS_COMPLETED = 2304;
+export declare const ATS_TRIGGER = 2560;
+export declare const ATS_FINAL_ACTION = 3328;
+export declare const ATS_TEST_STARTED = 3088;
+export declare const ATS_TEST_ENDED = 3104;
+export declare const ATS_TEST_ABORTED = 3120;
+export declare const ATS_ARGUMENT = 3136;
+export declare const ATS_RUNTIME = 3152;
+export declare const TEST_FFP = 2816;
+export declare const TEST_FFMAP = 2832;
+export declare const CALI_PARAM = 2848;
+export declare const CTRL_PARAM = 2864;
+export declare const ACTU_PARAM = 2880;
+export declare const SPECIMEN_CLAMPED = 2944;
+export declare const SPECIMEN_LOADING = 2960;
+export declare const SPECIMEN_BROKEN = 2976;
+export declare const SPECIMEN_RELEASED = 2992;
+export declare const API_DEBUG = 3584;
+export declare const SYNC_ALIGNED = 3840;
+export declare const SYNC_GROUP = 3856;
+export declare const SYNC_READY = 3872;
+export declare const SYNC_GO = 3888;
+export declare const SYNC_OK = 3904;
+export declare const SYNC_ABORTED = 3968;

package/domain/VtcMsgTypeConstant.js

@@ -0,0 +1,46 @@
+export const LAUNCH_STEP = 0x0100; // 启动，及以下正常步骤
+export const LAUNCH_ABORTED = 0x1000; // 启动异常中止
+export const LAUNCH_OK = 0x2000; // 启动正常完成
+export const CLOSE_STEP = 0x4000; // 关闭，及以下步骤
+export const CLOSE_OK = 0x8000; // 关闭正常完成
+export const RUN_MSG = 0x0200; // 运行时信息
+export const RUN_EVENT = 0x0300; // 运行中发生指定事件
+export const RUN_EVENT_TOUCH = 0x0310; // 运行中的触碰事件
+export const RUN_WARNING = 0x0400; // 运行时警告
+export const RUN_DEBUG = 0x0500; // 运行时跟踪信息
+export const ATS_LOADING = 0x0600; // ATS正在加载+ATS句柄(下同)
+export const ATS_LOAD_ABORTED = 0x0610; // ATS加载不成功
+export const ATS_LOAD_OK = 0x0620; // ATS加载成功
+export const ATS_STARTING = 0x0630; // ATS启动中
+export const ATS_STARTED = 0x0650; // ATS已经启动
+export const ATS_BREAK = 0x0660; // ATS(长时间动作)中断
+export const ATS_CONTINUE = 0x0670; // ATS(中断后)继续
+export const ATS_CATCH_CONTROLLER = 0x0680; // ATS抓住控制器
+export const ATS_RELEASE_CONTROLLER = 0x0690; // ATS释放控制器
+export const ATS_TERMINATING = 0x06A0; // ATS终止中
+export const ATS_ACTION = 0x0700; // ATS执行动作+句柄+轴
+export const ATS_ABORTED = 0x0800; // ATS异常退出
+export const ATS_COMPLETED = 0x0900; // ATS结束
+export const ATS_TRIGGER = 0x0A00; // ATS跳转触发器+句柄+轴
+export const ATS_FINAL_ACTION = 0x0D00; // ATS轴最终动作+句柄+轴
+export const ATS_TEST_STARTED = 0x0C10; // 驻留模式的试验开始+ATS句柄，与时序消息同时发出
+export const ATS_TEST_ENDED = 0x0C20;
+export const ATS_TEST_ABORTED = 0x0C30;
+export const ATS_ARGUMENT = 0x0C40; // 全局参数变化
+export const ATS_RUNTIME = 0x0C50; // 运行参数变化
+export const TEST_FFP = 0x0B00; // 侦测位移前馈比例
+export const TEST_FFMAP = 0x0B10; // 侦测位移前馈表
+export const CALI_PARAM = 0x0B20; // 测量通道的标定参数变化
+export const CTRL_PARAM = 0x0B30; // 闭环反馈通道的控制参数变化
+export const ACTU_PARAM = 0x0B40; // 作动器的参数变化
+export const SPECIMEN_CLAMPED = 0x0B80; // 试件
+export const SPECIMEN_LOADING = 0x0B90;
+export const SPECIMEN_BROKEN = 0x0BA0;
+export const SPECIMEN_RELEASED = 0x0BB0;
+export const API_DEBUG = 0x0E00; // 应用调用接口跟踪
+export const SYNC_ALIGNED = 0x0F00; // 对齐
+export const SYNC_GROUP = 0x0F10; // 成组
+export const SYNC_READY = 0x0F20; // 就绪
+export const SYNC_GO = 0x0F30; // 启动
+export const SYNC_OK = 0x0F40;
+export const SYNC_ABORTED = 0x0F80;

package/domain/ats/event/BaseAtsEvent.d.ts

@@ -3,5 +3,6 @@ export interface BaseAtsEvent {
     dateTime: Date;
     atsHandle: number;
     eventId: number;
+    actionTag: string;
     eventTag: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langjie-m-play",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",

package/server/RemoteWebService.d.ts

@@ -10,4 +10,4 @@ export declare const RemoteWebService: {
     usingCheck: (params: PlayUseSubmit) => Promise<boolean>;
     syncRuntimeInfo: (sn: string) => Promise<RuntimeInfo>;
 };
-export declare const request: (sn: any, pathname: any, params: any, headers?: {}) => Promise<any>;
+export declare const request: (sn: any, pathname: any, params: any, headers?: {}, isGet?: boolean) => Promise<any>;

package/server/RemoteWebService.js

@@ -37,13 +37,13 @@ export const RemoteWebService = {
         return yield request(sn, '/play/original/getTestingRuntimeInfo', { accountNo: sn });
     }),
 };
-export const request = (sn_1, pathname_1, params_1, ...args_1) => __awaiter(void 0, [sn_1, pathname_1, params_1, ...args_1], void 0, function* (sn, pathname, params, headers = {}) {
+export const request = (sn_1, pathname_1, params_1, ...args_1) => __awaiter(void 0, [sn_1, pathname_1, params_1, ...args_1], void 0, function* (sn, pathname, params, headers = {}, isGet = false) {
     let result;
     const { isHttps, httpUrl } = ServerConfigUtil.getRequestTargetInfo();
     if (isHttps) {
         // 走公网代理
         result = (yield axios({
-            method: 'post',
+            method: isGet ? 'get' : 'post',
             url: `${httpUrl}/cloudCustomerService/actionStation/request/proxy`,
             data: {
                 serialNo: sn,
@@ -63,7 +63,7 @@ export const request = (sn_1, pathname_1, params_1, ...args_1) => __awaiter(void
         }
         // 走本地环境
         result = (yield axios({
-            method: 'post',
+            method: isGet ? 'get' : 'post',
             url: `${httpUrl}:${port}${pathname}`,
             data: params,
             headers,

package/service/GtcServiceSocketIOImpl.d.ts

@@ -3,7 +3,6 @@ import { JsonRpcRequest } from "../domain/JsonRpcRequest";
 import { JsonRpcResponse } from "../domain/JsonRpcResponse";
 import { OutMsg } from "../domain/OutMsg";
 import { GtcCallBackMsg } from "../domain/GtcCallBackMsg";
-import { ReadDataDO } from "../domain/ReadDataDO";
 /**
  * 远程gtc服务socketIO实现
  */
@@ -11,12 +10,17 @@ declare class GtcServiceSocketIOImpl implements IGtcService {
     private socket;
     private connectStatus;
     private callbackMap;
+    private threadPool;
     constructor();
     init(url: string, connectCallback: () => void, disconnectCallback: () => void): Promise<boolean>;
     disconnect(): Promise<void>;
     call(request: JsonRpcRequest<any>): Promise<any>;
     reply(response: JsonRpcResponse<any, any>): void;
     event(response: JsonRpcResponse<OutMsg<GtcCallBackMsg>, any>): void;
-    dataGram(response: JsonRpcResponse<OutMsg<ReadDataDO>, any>): void;
+    /**
+     * 将数据加入处理队列（多线程模式）
+     * 使用 Web Worker 执行耗时计算，避免阻塞 UI 线程
+     */
+    dataGram<T>(rsp: T): void;
 }
 export default GtcServiceSocketIOImpl;

package/service/GtcServiceSocketIOImpl.js

@@ -14,6 +14,7 @@ class GtcServiceSocketIOImpl {
         this.connectStatus = ConnectStatusEnum.DISCONNECT;
         // Call Reply回调函数映射
         this.callbackMap = {};
+        // this.threadPool = new ThreadPoolUtil();
     }
     init(url, connectCallback, disconnectCallback) {
         return new Promise((resolve, reject) => {
@@ -112,9 +113,29 @@ class GtcServiceSocketIOImpl {
             PubSubUtil.publish(response.slaveInstId + ":" + SubKeyEnum.GTC_EVENT_KEY + ":" + response.result.serviceType + ":" + response.result.ctrlIndex, response.result.data);
         }
     }
-    dataGram(response) {
-        // 处理数据流
-        PubSubUtil.publish(response.slaveInstId + ":" + SubKeyEnum.GTC_DATA_GRAM_KEY + ":" + response.result.serviceType + ":" + response.result.ctrlIndex, response.result);
+    /**
+     * 将数据加入处理队列（多线程模式）
+     * 使用 Web Worker 执行耗时计算，避免阻塞 UI 线程
+     */
+    dataGram(rsp) {
+        const response = rsp;
+        const publishKey = response.slaveInstId + ":" + SubKeyEnum.GTC_DATA_GRAM_KEY + ":" +
+            response.result.serviceType + ":" + response.result.ctrlIndex;
+        // this.threadPool.pushTask({
+        //     compute: data => {
+        //         const timeStamp = Date.now();
+        //         while (Date.now() - timeStamp < 50) {
+        //
+        //         }
+        //         return { result: data.response.result };
+        //     },
+        //     // 传递给计算函数的数据
+        //     computeData: { response },
+        //     // 在主线程执行
+        //     callback: (response) => {
+        PubSubUtil.publish(publishKey, response.result);
+        //     }
+        // });
     }
 }
 export default GtcServiceSocketIOImpl;

package/service/GtcServiceWebSocketImpl.d.ts

@@ -3,7 +3,6 @@ import { JsonRpcRequest } from "../domain/JsonRpcRequest";
 import { JsonRpcResponse } from "../domain/JsonRpcResponse";
 import { OutMsg } from "../domain/OutMsg";
 import { GtcCallBackMsg } from "../domain/GtcCallBackMsg";
-import { ReadDataDO } from "../domain/ReadDataDO";
 /**
  * 远程gtc服务WebSocket实现
  */
@@ -20,6 +19,7 @@ declare class GtcServiceWebSocketImpl implements IGtcService {
     private m_reconnectAttempts;
     private m_isNormalClose;
     constructor();
+    buffer2GramJson(buffer: Uint8Array): void;
     init(url: string, connectCallback: () => void, disconnectCallback: () => void): Promise<boolean>;
     _initWebSocket(): Promise<boolean>;
     _reconnect(): void;
@@ -27,6 +27,6 @@ declare class GtcServiceWebSocketImpl implements IGtcService {
     call(request: JsonRpcRequest<any>): Promise<any>;
     reply(response: JsonRpcResponse<any, any>): void;
     event(response: JsonRpcResponse<OutMsg<GtcCallBackMsg>, any>): void;
-    dataGram(response: JsonRpcResponse<OutMsg<ReadDataDO>, any>): void;
+    dataGram<T>(rsp: T): void;
 }
 export default GtcServiceWebSocketImpl;

package/service/GtcServiceWebSocketImpl.js

@@ -14,6 +14,8 @@ import { PubSubUtil } from "../utils/PubSubUtil";
 import { SubKeyEnum } from "../utils/enums/SubKeyEnum";
 // @ts-ignore
 import { MsgEventTypeEnum } from "../domain/enums/MsgEventTypeEnum";
+import Dvb from "../utils/Dvb";
+import { DataGramUtil } from "../utils/DataGramUtil";
 /**
  * 远程gtc服务WebSocket实现
  */
@@ -33,6 +35,53 @@ class GtcServiceWebSocketImpl {
         //是否正常关闭,正常关闭不重连
         this.m_isNormalClose = false;
     }
+    buffer2GramJson(buffer) {
+        const retGramJson = {
+            "error": null,
+            "event": "R_GRAM_LIST",
+            "id": null,
+            "method": null,
+            "result": {
+                "ctrlIndex": 0,
+                "data": {
+                    "DataGramList": []
+                },
+                "msgEventType": 1,
+                "serviceType": 2
+            },
+            "slaveInstId": null,
+            "timestamp": 0
+        };
+        const tagLength = DataGramUtil.tagLength();
+        if (buffer.length % (tagLength * 4) != 0) {
+            console.error("length is err", tagLength, buffer.length);
+            return;
+        }
+        const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        const dataGramList = [];
+        // 单行长度 = 标签个数 × 4字节（uint32_t占4字节）
+        const singleLineLength = tagLength * 4;
+        for (let lineOffset = 0; lineOffset < buffer.length; lineOffset += singleLineLength) {
+            // 单个数据项的uint32数组（对应原line）
+            const singleLineItemList = [];
+            // 遍历当前数据项的所有标签，拼接4字节为uint32
+            for (let tagIdx = 0; tagIdx < tagLength; tagIdx++) {
+                // 计算当前标签在DataView中的字节偏移（行偏移 + 标签偏移×4字节）
+                const byteOffset = lineOffset + (tagIdx * 4);
+                const uint32Value = dataView.getUint32(byteOffset, true);
+                if (DataGramUtil.isDVB(tagIdx)) {
+                    const strValue = Dvb.Dvb2String(uint32Value);
+                    singleLineItemList.push(strValue);
+                }
+                else {
+                    singleLineItemList.push(uint32Value.toString(10));
+                }
+            }
+            dataGramList.push(singleLineItemList);
+        }
+        retGramJson.result.data.DataGramList = dataGramList;
+        this.dataGram(retGramJson);
+    }
     init(url, connectCallback, disconnectCallback) {
         this.m_connectCallback = connectCallback;
         this.m_disconnectCallback = disconnectCallback;
@@ -43,20 +92,39 @@ class GtcServiceWebSocketImpl {
     _initWebSocket() {
         const that = this;
         return new Promise((resolve, reject) => {
-            setTimeout(() => reject("服务器连接失败"), 2000);
+            const timeoutTimer = setTimeout(() => reject("服务器连接失败"), 2000);
             // 判断是否已经连接
             if (that.socket && (that.socket.readyState == WebSocket.OPEN || that.socket.readyState == WebSocket.CONNECTING)) {
                 resolve(true);
                 return;
             }
+            if (that.socket) {
+                that.socket.onopen = null;
+                that.socket.onmessage = null;
+                that.socket.onclose = null;
+                that.socket.onerror = null;
+                that.socket = null;
+            }
             that.socket = new WebSocket(that.m_url);
             that.socket.id = 0;
             that.socket.onopen = function () {
                 console.log("open success");
+                clearTimeout(timeoutTimer);
             };
             that.socket.onmessage = function (e) {
+                if (e.data instanceof Blob) {
+                    let blob = e.data;
+                    const reader = new FileReader();
+                    reader.onload = function (e) {
+                        let arrayBuffer = e.target.result;
+                        // @ts-ignore
+                        let bs = new Uint8Array(arrayBuffer);
+                        that.buffer2GramJson(bs);
+                    };
+                    reader.readAsArrayBuffer(blob);
+                    return;
+                }
                 let response = JSON.parse(e.data);
-                PubSubUtil.publish("", response);
                 switch (response.event) {
                     case JsonRpcEventEnum.REPLY:
                         that.reply(response);
@@ -81,7 +149,8 @@ class GtcServiceWebSocketImpl {
                         }
                         break;
                     }
-                    default: break;
+                    default:
+                        break;
                 }
             };
             that.socket.onclose = function () {
@@ -163,7 +232,8 @@ class GtcServiceWebSocketImpl {
             PubSubUtil.publish(response.slaveInstId + ":" + SubKeyEnum.GTC_EVENT_KEY + ":" + response.result.serviceType + ":" + response.result.ctrlIndex, response.result.data);
         }
     }
-    dataGram(response) {
+    dataGram(rsp) {
+        const response = rsp;
         // 处理数据流
         PubSubUtil.publish(response.slaveInstId + ":" + SubKeyEnum.GTC_DATA_GRAM_KEY + ":" + response.result.serviceType + ":" + response.result.ctrlIndex, response.result);
     }

package/service/IGtcService.d.ts

@@ -1,7 +1,6 @@
 import { JsonRpcRequest } from "../domain/JsonRpcRequest";
 import { JsonRpcResponse } from "../domain/JsonRpcResponse";
 import { OutMsg } from "../domain/OutMsg";
-import { ReadDataDO } from "../domain/ReadDataDO";
 import { GtcCallBackMsg } from "../domain/GtcCallBackMsg";
 /**
  * 远程gtc服务接口
@@ -12,6 +11,6 @@ interface IGtcService {
     call(request: JsonRpcRequest<any>): Promise<any>;
     reply(response: JsonRpcResponse<any, any>): any;
     event(response: JsonRpcResponse<OutMsg<GtcCallBackMsg>, any>): any;
-    dataGram(response: JsonRpcResponse<OutMsg<ReadDataDO>, any>): any;
+    dataGram<T>(response: T): any;
 }
 export default IGtcService;

package/service/MPlay.d.ts

@@ -22,6 +22,7 @@ export declare class MPlay {
     private ctrlRuntimeInfo;
     private ctrlMsgCallback;
     private channelHandleMap;
+    private static decodeId;
     /**
      * Connect to the MPlay server.
      * Direct Connection Mode.

package/service/MPlay.js

@@ -17,7 +17,17 @@ import { RemoteWebService } from "../server/RemoteWebService";
 import GtcServiceFactory from "./GtcServiceFactory";
 import { CommunicationTypeEnum } from "../domain/enums/CommunicationTypeEnum";
 import { ServerConfigUtil } from "../utils/ServerConfigUtil";
+import { DataGramUtil } from "../utils/DataGramUtil";
+import { ATS_ABORTED, ATS_ACTION, ATS_COMPLETED, ATS_STARTED } from "../domain/VtcMsgTypeConstant";
 export class MPlay {
+    static decodeId(msgCode) {
+        let id = (msgCode & 0x000F);
+        if (msgCode & 0x4000) {
+            id |= 0x0010;
+        }
+        let codeType = (msgCode & 0x3FF0);
+        return [codeType, id];
+    }
     /**
      * Connect to the MPlay server.
      * Direct Connection Mode.
@@ -90,35 +100,20 @@ export class MPlay {
             if (this.ctrlMsgCallback) {
                 this.ctrlMsgCallback(msg);
             }
-            // console.log(msg);
-            // console.log(ctrlIndex + "<<>>" + msg.msgId.toString(16));
-            if (msg.msgId === 0x2000) {
-                // PubSubUtil.publish(SubKeyEnum.LAUNCH_OK, { instId, ctrlIndex });
-            }
-            else if (msg.msgId >= 0x0620 && msg.msgId < 0x0630) {
-                // ats加载成功
-                // PubSubUtil.publish(SubKeyEnum.ATS_LOAD_OK, { instId, ctrlIndex });
-            }
-            else if (msg.msgId >= 0x0650 && msg.msgId < 0x0660) {
-                // ats启动成功
+            const msgDecodeResult = MPlay.decodeId(msg.msgId);
+            if (msgDecodeResult[0] === ATS_STARTED) {
                 PubSubUtil.publish(SubKeyEnum.ATS_START_OK, { instId, ctrlIndex });
             }
-            else if (msg.msgId >= 0x0700 && msg.msgId < 0x0800) {
-                // ats跳转到指定步骤
-                const hAts = msg.msgId & 0x00F0 >> 4;
-                PubSubUtil.publish(SubKeyEnum.ATS_JUMP_ACTION, { instId, ctrlIndex, hAts, step: msg.msg });
+            else if (msgDecodeResult[0] === ATS_ACTION) {
+                PubSubUtil.publish(SubKeyEnum.ATS_JUMP_ACTION, { instId, ctrlIndex, hAts: msgDecodeResult[1], step: msg.msg });
             }
-            else if (msg.msgId >= 0x0800 && msg.msgId < 0x0900) {
-                // ats异常停止
+            else if (msgDecodeResult[0] === ATS_ABORTED) {
                 PubSubUtil.publish(SubKeyEnum.ATS_TERMINATE_ABNORMAL, { instId, ctrlIndex });
-                const hAts = msg.msgId & 0x00F0 >> 4;
-                delete this.atsHandleNameMap[hAts];
+                delete this.atsHandleNameMap[msgDecodeResult[1]];
             }
-            else if (msg.msgId >= 0x0900 && msg.msgId < 0x0910) {
-                // ats正常停止
+            else if (msgDecodeResult[0] === ATS_COMPLETED) {
                 PubSubUtil.publish(SubKeyEnum.ATS_TERMINATE, { instId, ctrlIndex });
-                const hAts = msg.msgId & 0x00F0 >> 4;
-                delete this.atsHandleNameMap[hAts];
+                delete this.atsHandleNameMap[msgDecodeResult[1]];
             }
         });
         GtcClient.listenAtsEventMsg(this.instId, this.serviceType, this.ctrlIndex, (msgList) => {
@@ -238,7 +233,7 @@ export class MPlay {
             this.ctrlRuntimeInfo = runtimeInfo;
             if (runtimeInfo && runtimeInfo.atsInfoList && runtimeInfo.atsInfoList.length > 0) {
                 runtimeInfo.atsInfoList.forEach(atsInfo => {
-                    this.atsHandleNameMap[atsInfo.handle] = atsInfo.atsName;
+                    this.atsHandleNameMap[atsInfo.handle] = atsInfo.ctrlTag + '-' + atsInfo.atsName;
                     if (atsInfo.started) {
                         this.atsStartedMark[atsInfo.handle] = true;
                     }
@@ -256,6 +251,7 @@ export class MPlay {
     subscribeForDatagram(tags, fn) {
         return __awaiter(this, void 0, void 0, function* () {
             this.dataGramCallBack = fn;
+            DataGramUtil.registerTag(tags);
             const result = yield GtcClient.subscribeForDatagram(this.instId, this.serviceType, tags);
             result.forEach(item => {
                 this.channelHandleMap[item.tag] = item.handle;
@@ -291,7 +287,7 @@ export class MPlay {
     load(atsScriptName, actualCtrlTag, fn) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const atsHandle in this.atsHandleNameMap) {
-                if (this.atsHandleNameMap[atsHandle] !== atsScriptName) {
+                if (this.atsHandleNameMap[atsHandle] !== actualCtrlTag + '-' + atsScriptName) {
                     continue;
                 }
                 const atsInfo = this.ctrlRuntimeInfo.atsInfoList.filter(atsInfo => atsInfo.handle === Number(atsHandle))[0];
@@ -302,6 +298,8 @@ export class MPlay {
                         atsParam: atsInfo.atsParams,
                         atsButtonList: [],
                         atsFile: atsInfo.atsFile,
+                        ctrlTag: atsInfo.ctrlTag,
+                        atsName: atsInfo.atsName,
                     };
                 }
             }
@@ -311,7 +309,7 @@ export class MPlay {
                 throw new Error("Failed to load ATS script");
             }
             this.atsStartedMark[atsHandle] = false;
-            this.atsHandleNameMap[atsHandle] = atsScriptName;
+            this.atsHandleNameMap[atsHandle] = actualCtrlTag + '-' + atsScriptName;
             this.atsEventCallbackMap[atsHandle] = fn;
             // @ts-ignore
             return atsLoadResponse;
@@ -327,7 +325,7 @@ export class MPlay {
             const atsStartSynchronizer = new TaskSynchronizer();
             PubSubUtil.subscribe(SubKeyEnum.ATS_START_OK, atsHandle.toString(), (eventMsg) => __awaiter(this, void 0, void 0, function* () { return atsStartSynchronizer.finishTaskKey(atsHandle.toString()); }));
             atsStartSynchronizer.addTaskKey(atsHandle.toString());
-            yield GtcClient.atsStart(this.instId, this.serviceType, this.ctrlIndex, atsHandle, this.atsHandleNameMap[atsHandle]);
+            yield GtcClient.atsStart(this.instId, this.serviceType, this.ctrlIndex, atsHandle, this.atsHandleNameMap[atsHandle].split('-')[1]);
             yield atsStartSynchronizer.waitAll();
             PubSubUtil.unsubscribe(SubKeyEnum.ATS_START_OK, atsHandle.toString());
             this.atsStartedMark[atsHandle] = true;

package/utils/DataGramUtil.d.ts

@@ -0,0 +1,17 @@
+export declare class DataGramUtil {
+    private static TAG_LIST;
+    private static FLAG_TAG_LIST;
+    /**
+     * 注册订阅串
+     *
+     * @param tags 订阅串
+     */
+    static registerTag(tags: string): void;
+    /**
+     * 根据索引判断是否DVB码
+     *
+     * @param index
+     */
+    static isDVB(index: number): boolean;
+    static tagLength(): number;
+}

package/utils/DataGramUtil.js

@@ -0,0 +1,29 @@
+export class DataGramUtil {
+    /**
+     * 注册订阅串
+     *
+     * @param tags 订阅串
+     */
+    static registerTag(tags) {
+        DataGramUtil.TAG_LIST = tags.split(',');
+    }
+    /**
+     * 根据索引判断是否DVB码
+     *
+     * @param index
+     */
+    static isDVB(index) {
+        const tag = DataGramUtil.TAG_LIST[index];
+        for (let i = 0; i < DataGramUtil.FLAG_TAG_LIST.length; i++) {
+            if (tag.endsWith(DataGramUtil.FLAG_TAG_LIST[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static tagLength() {
+        return DataGramUtil.TAG_LIST.length;
+    }
+}
+DataGramUtil.TAG_LIST = [];
+DataGramUtil.FLAG_TAG_LIST = ['Time', 'Event', 'Intent'];

package/utils/Dvb.d.ts

@@ -0,0 +1,13 @@
+declare class Dvb {
+    static DvbIsPositive(dv: number): boolean;
+    static DvbIsInteger(dv: number): boolean;
+    static DotOfDvb(dv: number): number;
+    static Dvb2Float(dv: number): number;
+    static Dvb2Int(dvb: number): number;
+    static Float2Dvb(fv: number, dot: number): number;
+    static Round2Int(f: number): number;
+    static Int2Dvb(iv: number): number;
+    static Dvb2String(dv: any): number;
+    static String2Dvb(str: string): number;
+}
+export default Dvb;

package/utils/Dvb.js

@@ -0,0 +1,174 @@
+const FMULTI = [1.0, 0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001];
+const MULTI = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000];
+const DECIMUL = [1, 10, 100, 1000, 10000, 100000, 1000000];
+const NEGABIT = 0x80000000;
+class Dvb {
+    static DvbIsPositive(dv) {
+        return ((dv & NEGABIT) == 0);
+    }
+    static DvbIsInteger(dv) {
+        return ((dv & 0x70000000) == 0);
+    }
+    static DotOfDvb(dv) {
+        return ((dv & 0x70000000) >> 28);
+    }
+    static Dvb2Float(dv) {
+        let dot = ((dv & 0x70000000) >> 28);
+        let iv = Dvb.Dvb2Int(dv & 0x8FFFFFFF);
+        let v = iv * FMULTI[dot];
+        return (v);
+    }
+    static Dvb2Int(dvb) {
+        let dot = Dvb.DotOfDvb(dvb);
+        if (dot != 0) {
+            dvb >>= (dot * 4);
+        }
+        let iv = 0;
+        for (let i = 0; i < (7 - dot); i++) {
+            iv += (dvb & 0x0000000f) * DECIMUL[i];
+            dvb >>= 4;
+        }
+        return ((dvb & 0x00000008) > 0 ? -iv : iv);
+    }
+    static Float2Dvb(fv, dot) {
+        dot = Math.max(0, dot);
+        dot = Math.min(7, dot);
+        let mf = fv * MULTI[dot];
+        mf = Math.max(-9999999.0, mf);
+        mf = Math.min(9999999.0, mf);
+        let dvb = Dvb.Int2Dvb(Dvb.Round2Int(mf));
+        return (dvb | (dot << 28));
+    }
+    static Round2Int(f) {
+        if (f >= 0.0) {
+            return (Number.parseInt(String(f + 0.4)));
+        }
+        else {
+            return (Number.parseInt(String(f - 0.4)));
+        }
+    }
+    static Int2Dvb(iv) {
+        let isNega = (iv < 0);
+        if (isNega) {
+            iv = -iv;
+        }
+        let shift = 0;
+        let dvb = 0;
+        for (let i = 0; i < 7; i++) {
+            let deci = iv % 10;
+            if (deci != 0) {
+                dvb |= (deci << shift);
+            }
+            iv /= 10;
+            shift += 4;
+        }
+        if (isNega) {
+            dvb |= NEGABIT;
+        }
+        return (dvb);
+    }
+    static Dvb2String(dv) {
+        let negative = !Dvb.DvbIsPositive(dv);
+        let dot = Dvb.DotOfDvb(dv);
+        let dwidth = 7;
+        let mask = 0x0f000000;
+        let i = 0;
+        let strBuf = [];
+        for (i = 0; i < 7; i++) { // 确定有效数字宽度
+            if (mask & dv) {
+                break;
+            }
+            dwidth--;
+            mask >>= 4;
+        }
+        if (dwidth == 0) { // 特例全0
+            let p = 0;
+            // @ts-ignore
+            strBuf[p++] = '0'.charCodeAt();
+            if (dot >= 1) {
+                // @ts-ignore
+                strBuf[p++] = '.'.charCodeAt();
+                for (let i = 0; i < dot; i++) {
+                    // @ts-ignore
+                    strBuf[p++] = "0".charCodeAt();
+                }
+            }
+            strBuf[p++] = 0;
+            return String.fromCharCode.apply(String, strBuf).replaceAll("\0", "");
+        }
+        let stringLen;
+        if (dot == 0) {
+            stringLen = dwidth;
+        }
+        else {
+            stringLen = Math.max(dwidth + 1, dot + 2);
+        }
+        if (negative) {
+            stringLen++;
+        }
+        strBuf[stringLen] = 0; // 从末尾开始形成字符串
+        let dcount = 0;
+        let needDot = (dot != 0);
+        for (i = stringLen - 1; i >= 0; i--) {
+            if (needDot && dcount == dot) {
+                needDot = false;
+                // @ts-ignore
+                strBuf[i] = ".".charCodeAt();
+            }
+            else if (dcount < dwidth) {
+                let d = (dv & 0x0000000f);
+                if (d < 10) {
+                    // @ts-ignore
+                    strBuf[i] = d + "0".charCodeAt();
+                }
+                else {
+                    // @ts-ignore
+                    strBuf[i] = (d - 10 + "A".charCodeAt());
+                }
+                dv >>= 4;
+                dcount++;
+            }
+            else if (i == 0 && negative) {
+                // @ts-ignore
+                strBuf[i] = '-'.charCodeAt();
+            }
+            else {
+                // @ts-ignore
+                strBuf[i] = '0'.charCodeAt();
+                dcount++;
+            }
+        }
+        return String.fromCharCode.apply(String, strBuf).replaceAll("\0", "");
+    }
+    // 隐含条件：str是一个格式良好的字符串，没有非法字符，顶多有一个小数点，负号一定在首位，有效数字不超过7个
+    static String2Dvb(str) {
+        let rightIndex = str.length - 1; // 字符串数字右端位置
+        let negative = (str[0] == '-') ? 1 : 0;
+        let leftIndex = negative ? 1 : 0; // 字符串数字左端位置
+        let dvb = 0x00000000;
+        let dotFound = 0;
+        let dot = 0;
+        for (let i = leftIndex; i <= rightIndex; i++) { // 从左端高位开始转换，方便移位
+            let c = str[i];
+            if (c == '.') { // 遇到小数点
+                dotFound = 1;
+            }
+            else { // 遇到数字
+                dvb <<= 4;
+                // @ts-ignore
+                dvb |= (c - '0');
+                if (dotFound) {
+                    dot++;
+                }
+            }
+        }
+        if (negative) {
+            dvb |= NEGABIT;
+        }
+        if (dot > 0) {
+            dvb |= (dot << 28);
+        }
+        return (dvb);
+    }
+}
+export default Dvb;

package/utils/ThreadPoolUtil.d.ts

@@ -0,0 +1,48 @@
+export interface WorkerTask {
+    compute?: (data?: any) => any;
+    computeData?: any;
+    callback?: (result?: any) => void;
+}
+export declare class ThreadPoolUtil {
+    private dataGramQueue;
+    private workerPool;
+    private readonly maxWorkers;
+    private taskIdCounter;
+    private pendingTasks;
+    private workerIndex;
+    private useWorker;
+    constructor();
+    /**
+     * 添加待执行任务
+     */
+    pushTask(task: WorkerTask): void;
+    /**
+     * 处理下一个任务
+     */
+    private processNextTask;
+    /**
+     * 在主线程执行任务（兼容旧接口）
+     */
+    private executeOnMainThread;
+    /**
+     * 使用 Web Worker 执行任务
+     */
+    private executeWithWorker;
+    /**
+     * 获取可用的 Worker（轮询方式）
+     */
+    private getAvailableWorker;
+    /**
+     * 启动工作池，创建多个 Web Worker
+     */
+    private startWorkerPool;
+    /**
+     * 创建内联 Worker（通过 Blob URL）
+     * 这是一个备选方案，当无法加载外部 Worker 文件时使用
+     */
+    private createInlineWorker;
+    /**
+     * 销毁 Worker 池
+     */
+    destroy(): void;
+}

package/utils/ThreadPoolUtil.js

@@ -0,0 +1,299 @@
+export class ThreadPoolUtil {
+    constructor() {
+        // 数据流处理队列和工作池
+        this.dataGramQueue = [];
+        this.workerPool = [];
+        this.maxWorkers = 1; // 最大并发工作线程数
+        this.taskIdCounter = 0;
+        this.pendingTasks = new Map();
+        this.workerIndex = 0;
+        this.useWorker = true; // 是否使用 Worker
+        // 初始化工作池
+        this.startWorkerPool();
+    }
+    /**
+     * 添加待执行任务
+     */
+    pushTask(task) {
+        this.dataGramQueue.push(task);
+        this.processNextTask();
+    }
+    /**
+     * 处理下一个任务
+     */
+    processNextTask() {
+        if (this.dataGramQueue.length === 0) {
+            return;
+        }
+        const task = this.dataGramQueue.shift();
+        if (!task) {
+            return;
+        }
+        // 检查是否是新接口（有 compute 函数）且 Worker 可用
+        if (this.useWorker && 'compute' in task && task.compute) {
+            // 使用 Web Worker 执行计算部分
+            this.executeWithWorker(task);
+        }
+        else {
+            // 兼容旧接口：在主线程执行，或者 Worker 不可用时回退
+            this.executeOnMainThread(task);
+        }
+    }
+    /**
+     * 在主线程执行任务（兼容旧接口）
+     */
+    executeOnMainThread(task) {
+        try {
+            let result;
+            if (task.compute) {
+                result = task.compute();
+            }
+            if (task.callback) {
+                task.callback(result);
+            }
+        }
+        catch (error) {
+            console.error('主线程执行任务时出错:', error);
+        }
+        // 继续处理下一个任务
+        this.processNextTask();
+    }
+    /**
+     * 使用 Web Worker 执行任务
+     */
+    executeWithWorker(task) {
+        const taskId = `task_${this.taskIdCounter++}`;
+        const worker = this.getAvailableWorker();
+        // 保存任务信息
+        this.pendingTasks.set(taskId, { task });
+        // 将计算函数序列化为字符串
+        let computeFnString = '';
+        if (task.compute) {
+            // 获取函数体
+            const fnString = task.compute.toString();
+            // 提取函数体部分（去掉 function 声明）
+            if (fnString.startsWith('function')) {
+                // function name(data) { ... }
+                const bodyMatch = fnString.match(/\{([\s\S]*)\}$/);
+                if (bodyMatch) {
+                    computeFnString = bodyMatch[1];
+                }
+            }
+            else if (fnString.includes('=>')) {
+                // 箭头函数: (data) => { ... } 或 (data) => ...
+                // 更精确的匹配：找到 => 后面的部分
+                const arrowIndex = fnString.indexOf('=>');
+                if (arrowIndex !== -1) {
+                    let bodyPart = fnString.substring(arrowIndex + 2).trim();
+                    // 如果函数体用 {} 包裹，提取内容
+                    if (bodyPart.startsWith('{')) {
+                        // 找到匹配的 }
+                        let braceCount = 0;
+                        let endIndex = -1;
+                        for (let i = 0; i < bodyPart.length; i++) {
+                            if (bodyPart[i] === '{')
+                                braceCount++;
+                            if (bodyPart[i] === '}')
+                                braceCount--;
+                            if (braceCount === 0 && bodyPart[i] === '}') {
+                                endIndex = i;
+                                break;
+                            }
+                        }
+                        if (endIndex !== -1) {
+                            computeFnString = bodyPart.substring(1, endIndex).trim();
+                        }
+                        else {
+                            // 如果找不到匹配的 }，使用整个 bodyPart（去掉开头的 {）
+                            computeFnString = bodyPart.substring(1).trim();
+                        }
+                    }
+                    else {
+                        // 单行表达式，添加 return
+                        computeFnString = `return ${bodyPart}`;
+                    }
+                }
+            }
+            else {
+                computeFnString = fnString;
+            }
+        }
+        // 验证 Worker 对象
+        if (!worker) {
+            console.error('Worker 对象为空，无法发送消息');
+            this.executeOnMainThread(task);
+            return;
+        }
+        // 发送任务到 Worker
+        const message = {
+            type: 'TASK',
+            task: {
+                id: taskId,
+                computeFn: computeFnString,
+                data: task.computeData
+            }
+        };
+        try {
+            worker.postMessage(message);
+        }
+        catch (e) {
+            console.error('发送消息到 Worker 失败:', e);
+            // 如果发送失败，回退到主线程执行
+            this.executeOnMainThread(task);
+        }
+        // 设置 Worker 消息监听（一次性）
+        const messageHandler = (e) => {
+            const message = e.data;
+            if (message.taskId === taskId) {
+                worker.removeEventListener('message', messageHandler);
+                const pendingTask = this.pendingTasks.get(taskId);
+                if (pendingTask) {
+                    this.pendingTasks.delete(taskId);
+                    if (message.type === 'RESULT') {
+                        // 计算完成，在主线程执行回调
+                        try {
+                            if ('callback' in pendingTask.task && pendingTask.task.callback) {
+                                pendingTask.task.callback(message.result);
+                            }
+                        }
+                        catch (error) {
+                            console.error('执行回调函数时出错:', error);
+                        }
+                    }
+                    else if (message.type === 'ERROR') {
+                        console.error(`Worker 执行任务 ${taskId} 时出错:`, message.error);
+                    }
+                }
+                // 继续处理下一个任务
+                this.processNextTask();
+            }
+        };
+        worker.addEventListener('message', messageHandler);
+        // 错误处理
+        const errorHandler = (error) => {
+            worker.removeEventListener('error', errorHandler);
+            console.error(`Worker 错误:`, error);
+            const pendingTask = this.pendingTasks.get(taskId);
+            if (pendingTask) {
+                this.pendingTasks.delete(taskId);
+            }
+            this.processNextTask();
+        };
+        worker.addEventListener('error', errorHandler);
+    }
+    /**
+     * 获取可用的 Worker（轮询方式）
+     */
+    getAvailableWorker() {
+        const worker = this.workerPool[this.workerIndex];
+        this.workerIndex = (this.workerIndex + 1) % this.workerPool.length;
+        return worker;
+    }
+    /**
+     * 启动工作池，创建多个 Web Worker
+     */
+    startWorkerPool() {
+        try {
+            for (let i = 0; i < this.maxWorkers; i++) {
+                let worker;
+                let workerType = '';
+                // 优先使用内联 Worker（更可靠，不依赖外部文件）
+                try {
+                    worker = this.createInlineWorker();
+                    workerType = 'inline (Blob URL)';
+                }
+                catch (e) {
+                    throw e;
+                }
+                // 验证 Worker 对象
+                if (!worker) {
+                    throw new Error(`Worker ${i} 对象为空`);
+                }
+                // 添加 Worker 错误监听
+                worker.addEventListener('error', (error) => {
+                    console.error(`Worker ${i} 错误:`, error);
+                    console.error('错误详情:', error.message, error.filename, error.lineno);
+                });
+                this.workerPool.push(worker);
+            }
+        }
+        catch (error) {
+            console.warn('无法创建 Web Worker，将回退到主线程执行:', error);
+            // 如果 Worker 创建失败，标记为不使用 Worker，所有任务将在主线程执行
+            this.useWorker = false;
+        }
+    }
+    /**
+     * 创建内联 Worker（通过 Blob URL）
+     * 这是一个备选方案，当无法加载外部 Worker 文件时使用
+     */
+    createInlineWorker() {
+        // Worker 代码（从 worker.ts 复制，但需要是纯 JavaScript）
+        const workerCode = `
+            self.onmessage = function(e) {
+                const message = e.data;
+                
+                if (message.type === 'TERMINATE') {
+                    self.close();
+                    return;
+                }
+                
+                if (message.type === 'TASK' && message.task) {
+                    try {
+                        const task = message.task;
+                        const startTime = Date.now();
+                        
+                        if (task.computeFn) {
+                            try {
+                                const computeFunction = new Function('data', task.computeFn);
+                                const result = computeFunction(task.data);
+                                
+                                const endTime = Date.now();
+                                
+                                self.postMessage({
+                                    type: 'RESULT',
+                                    taskId: task.id,
+                                    result: result,
+                                    duration: endTime - startTime
+                                });
+                            } catch (fnError) {
+                                console.error('内联 Worker 函数执行错误:', fnError);
+                                throw fnError;
+                            }
+                        } else {
+                            self.postMessage({
+                                type: 'RESULT',
+                                taskId: task.id,
+                                result: null,
+                                duration: Date.now() - startTime
+                            });
+                        }
+                    } catch (error) {
+                        console.error('内联 Worker 捕获到错误:', error);
+                        self.postMessage({
+                            type: 'ERROR',
+                            taskId: message.task?.id || '',
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                }
+            };
+        `;
+        const blob = new Blob([workerCode], { type: 'application/javascript' });
+        const workerUrl = URL.createObjectURL(blob);
+        return new Worker(workerUrl);
+    }
+    /**
+     * 销毁 Worker 池
+     */
+    destroy() {
+        // 终止所有 Worker
+        this.workerPool.forEach(worker => {
+            worker.postMessage({ type: 'TERMINATE' });
+            worker.terminate();
+        });
+        this.workerPool = [];
+        this.pendingTasks.clear();
+        this.dataGramQueue = [];
+    }
+}

package/utils/worker.js

@@ -0,0 +1,99 @@
+// // Web Worker 文件 - 在后台线程中执行耗时计算任务
+//
+// interface WorkerTask {
+//     id: string;
+//     computeFn: string; // 序列化的计算函数代码
+//     data?: any; // 传递给计算函数的数据
+// }
+//
+// interface WorkerMessage {
+//     type: 'TASK' | 'TERMINATE';
+//     task?: WorkerTask;
+// }
+//
+// interface WorkerResponse {
+//     type: 'RESULT' | 'ERROR';
+//     taskId: string;
+//     result?: any;
+//     error?: string;
+//     duration?: number;
+//     errorStack?: string;
+// }
+//
+// // Worker 初始化日志
+// console.log('外部 Worker 初始化完成');
+//
+// // Worker 接收消息
+// self.onmessage = function(e: MessageEvent<WorkerMessage>) {
+//     console.log(3333, '外部 Worker 收到消息:', e.data);
+//     const message = e.data;
+//
+//     // 处理测试消息
+//     if ((message as any).type === 'TEST') {
+//         console.log('外部 Worker 收到测试消息');
+//         self.postMessage({ type: 'TEST_RESPONSE', received: true });
+//         return;
+//     }
+//
+//     if (message.type === 'TERMINATE') {
+//         self.close();
+//         return;
+//     }
+//
+//     if (message.type === 'TASK' && message.task) {
+//         try {
+//             const task = message.task;
+//             const startTime = Date.now();
+//
+//             // 执行计算任务
+//             // 由于函数无法直接序列化，我们使用 Function 构造函数来执行
+//             // 注意：这里只执行纯计算，不访问 DOM 或主线程 API
+//             if (task.computeFn) {
+//                 // 使用 Function 构造函数创建函数
+//                 // 注意：这需要函数体是自包含的，不能访问外部变量
+//                 console.log('Worker 准备执行函数，函数体:', task.computeFn);
+//                 console.log('Worker 准备执行函数，数据:', task.data);
+//                 try {
+//                     const computeFunction = new Function('data', task.computeFn);
+//                     const result = computeFunction(task.data);
+//                     console.log('Worker 函数执行成功，结果:', result);
+//
+//                     const endTime = Date.now();
+//
+//                     // 发送结果回主线程
+//                     const response: WorkerResponse = {
+//                         type: 'RESULT',
+//                         taskId: task.id,
+//                         result: result,
+//                         duration: endTime - startTime
+//                     };
+//                     self.postMessage(response);
+//                 } catch (fnError) {
+//                     console.error('Worker 函数执行错误:', fnError);
+//                     throw fnError;
+//                 }
+//             } else {
+//                 // 如果没有计算函数，只是通知任务完成
+//                 const response: WorkerResponse = {
+//                     type: 'RESULT',
+//                     taskId: task.id,
+//                     result: null,
+//                     duration: Date.now() - startTime
+//                 };
+//                 self.postMessage(response);
+//             }
+//         } catch (error) {
+//             // 发送错误回主线程
+//             console.error('Worker 捕获到错误:', error);
+//             const response: WorkerResponse = {
+//                 type: 'ERROR',
+//                 taskId: message.task?.id || '',
+//                 error: error instanceof Error ? error.message : String(error),
+//                 // 添加更多错误信息
+//                 errorStack: error instanceof Error ? error.stack : undefined
+//             };
+//             self.postMessage(response);
+//         }
+//     }
+// };
+//