skyeye-sdk-js 1.0.0

package/dist/SkyEyeClient.js

@@ -0,0 +1,831 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkyEyeClient = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const skyeye_rpc_grpc_pb_1 = require("./proto/skyeye_rpc_grpc_pb");
+const RequestFactory_1 = require("./RequestFactory");
+const GetCpuListResponse_1 = require("./response/GetCpuListResponse");
+const Cpu_1 = require("./models/Cpu");
+const GetDeviceListResponse_1 = require("./response/GetDeviceListResponse");
+const GetRunningStateResponse_1 = require("./response/GetRunningStateResponse");
+const Register_1 = require("./models/Register");
+const GetDeviceTreeResponse_1 = require("./response/GetDeviceTreeResponse");
+const ParseBoardUtils_1 = require("./utils/ParseBoardUtils");
+const GetAllDeviceInfoResponse_1 = require("./response/GetAllDeviceInfoResponse");
+const GetRamAddrInfoResponse_1 = require("./response/GetRamAddrInfoResponse");
+const Device_1 = require("./models/Device");
+const FaultInjectType_1 = require("./models/FaultInjectType");
+const FaultInjectItem_1 = require("./models/FaultInjectItem");
+const GetFaultInjectListResponse_1 = require("./response/GetFaultInjectListResponse");
+const GetDisassembleInfoResponse_1 = require("./response/GetDisassembleInfoResponse");
+const InstructionItem_1 = require("./models/InstructionItem");
+const GetCpuRegisterInfoResponse_1 = require("./response/GetCpuRegisterInfoResponse");
+const SkyEyeSDKException_1 = require("./exception/SkyEyeSDKException");
+let client = null;
+// ----------------------------当前运行程序的设备树----------------------------------------//
+const boardMap = new Map();
+class SkyEyeClient extends skyeye_rpc_grpc_pb_1.JSONTransmissionClient {
+    constructor(host, port) {
+        super(host + ":" + port, grpc.credentials.createInsecure());
+        this.host = host;
+        this.port = port;
+    }
+    printRequestLog(request) {
+        if (request.getRequest() != null) {
+            const base = JSON.parse(request.getRequest());
+            if (base.request.name === "SE_get_running_status" || base.request.name === "SE_get_all_class_info") {
+                return;
+            }
+            console.log("客户端请求-- ", JSON.stringify(base));
+        }
+    }
+    printResponseLog(ackObj) {
+        if (ackObj != null) {
+            const name = ackObj.name;
+            if (name === "SE_get_running_status" || name === "SE_get_all_class_info") {
+                return;
+            }
+            console.log(`客户端响应-- `, ackObj);
+        }
+    }
+    call(request) {
+        const _super = Object.create(null, {
+            callSkyEye: { get: () => super.callSkyEye }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.printRequestLog(request);
+                const response = yield new Promise((resolve, reject) => {
+                    _super.callSkyEye.call(this, request, (error, response) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(response);
+                        }
+                    });
+                });
+                // const res = JSON.parse(response.toString());
+                // console.log("res:",res)
+                const ackObj = JSON.parse(response.toString()).ack;
+                this.printResponseLog(ackObj);
+                return ackObj;
+            }
+            catch (error) {
+                console.error("Error during gRPC call:", error);
+                throw error;
+            }
+        });
+    }
+    runScriptRequest(filename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().runScriptRequest(filename));
+            }
+            catch (error) {
+                console.error("Error during runScriptRequest:", error);
+                throw error;
+            }
+        });
+    }
+    runCommand() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().runCommand());
+            }
+            catch (error) {
+                console.error("Error during runCommand:", error);
+                throw error;
+            }
+        });
+    }
+    stopCommand() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().stopCommand());
+            }
+            catch (error) {
+                console.error("Error during stopCommand:", error);
+                throw error;
+            }
+        });
+    }
+    quitCommand() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().quitCommand());
+            }
+            catch (error) {
+                console.error("Error during quitCommand:", error);
+                throw error;
+            }
+        });
+    }
+    getCpuList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = new GetCpuListResponse_1.GetCpuListResponse();
+            try {
+                const call = yield this.call(RequestFactory_1.RequestFactory.getInstance().getCpuList());
+                if (call != null) {
+                    response.isSuccess = true;
+                    if (call.result != null) {
+                        const cpuItems = new Array();
+                        call.result.forEach(element => {
+                            const item = new Cpu_1.Cpu(null);
+                            if (element.classname) {
+                                item.setClassName(element.classname);
+                            }
+                            if (element.objname) {
+                                item.setName(element.objname);
+                            }
+                            if (element.mach) {
+                                if (boardMap.has(String(element.mach))) {
+                                    item.setParent(boardMap.get(String(element.mach)));
+                                }
+                            }
+                            cpuItems.push(item);
+                        });
+                        response.setCpuList(cpuItems);
+                    }
+                }
+                else {
+                    throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                }
+                return response;
+            }
+            catch (error) {
+                console.error("Error during getCpuList:", error);
+                throw error;
+            }
+        });
+    }
+    enableDeviceWork(deviceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().enableDeviceWork(deviceName));
+            }
+            catch (error) {
+                console.error("Error during enableDeviceWork:", error);
+                throw error;
+            }
+        });
+    }
+    disableDeviceWork(deviceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().disableDeviceWork(deviceName));
+            }
+            catch (error) {
+                console.error("Error during disableDeviceWork:", error);
+                throw error;
+            }
+        });
+    }
+    changeDir(skyeyeProjectRootDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().changeDir(skyeyeProjectRootDir));
+            }
+            catch (error) {
+                console.error("Error during changeDir:", error);
+                throw error;
+            }
+        });
+    }
+    getRunningDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().getRunningDeviceInfo());
+            }
+            catch (error) {
+                console.error("Error during getRunningDeviceInfo:", error);
+                throw error;
+            }
+        });
+    }
+    getSimulationTime(cpuName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().getSimulationTime(cpuName));
+            }
+            catch (error) {
+                console.error("Error during getCurrentSimulationTime:", error);
+                throw error;
+            }
+        });
+    }
+    getCurrentSimulationTime() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cpuList = (yield this.getCpuList()).getCpuList();
+            if (cpuList.length > 0) {
+                return this.getSimulationTime(cpuList[0].getName());
+            }
+            else {
+                console.error("无法获取cpu，请确认cpu是否存在:");
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+            }
+        });
+    }
+    getDeviceList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = new GetDeviceListResponse_1.GetDeviceListResponse();
+            try {
+                const call = yield this.call(RequestFactory_1.RequestFactory.getInstance().getDeviceList());
+                console.log("getDeviceList:", call);
+                if (call != null) {
+                    response.isSuccess = true;
+                    const result = call.result;
+                    if (typeof result === 'object' && result !== null) {
+                        const objectNode = result;
+                        const it = Object.entries(objectNode);
+                        for (const machine of it) {
+                            const machName = machine[0];
+                            const devices = machine[1];
+                            if (typeof devices === 'object' && devices !== null) {
+                                const deviceNames = Object.keys(devices);
+                                for (const deviceName of deviceNames) {
+                                    const device = new Device_1.Device(null);
+                                    const items = devices[deviceName];
+                                    device.name = deviceName;
+                                    if (boardMap.has(machName)) {
+                                        device.parent = boardMap.get(machName);
+                                    }
+                                    if (items && items.hasOwnProperty("classname")) {
+                                        device.className = items["classname"];
+                                    }
+                                    response.deviceList.push(device);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.error("Error during getPC:", error);
+                throw error;
+            }
+            return response;
+        });
+    }
+    getPC(cpuName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().getCurrentPC(cpuName));
+            }
+            catch (error) {
+                console.error("Error during getPC:", error);
+                throw error;
+            }
+        });
+    }
+    getCurrentPC() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cpuList = (yield this.getCpuList()).getCpuList();
+            if (cpuList != null && cpuList.length > 0) {
+                try {
+                    return yield this.call(RequestFactory_1.RequestFactory.getInstance().getCurrentPC(cpuList[0].getName()));
+                }
+                catch (error) {
+                    console.error("Error during getCurrentPC:", error);
+                    throw error;
+                }
+            }
+            else {
+                console.error("无法获取cpu，请确认cpu是否存在:");
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+            }
+        });
+    }
+    getCpuMips(cpuName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().getCpuMips(cpuName));
+            }
+            catch (error) {
+                console.error("Error during getCurrentRunningState:", error);
+                throw error;
+            }
+        });
+    }
+    getCurrentCpuMips() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cpuList = (yield this.getCpuList()).getCpuList();
+            console.log("测试", cpuList[0].getName());
+            if (cpuList != null && cpuList.length > 0) {
+                try {
+                    return yield this.call(RequestFactory_1.RequestFactory.getInstance().getCpuMips(cpuList[0].getName()));
+                }
+                catch (error) {
+                    console.error("Error during getCurrentRunningState:", error);
+                    throw error;
+                }
+            }
+            else {
+                console.error("无法获取cpu，请确认cpu是否存在:");
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+            }
+        });
+    }
+    getGlobalVarValue(cpuName, varName, bytesNum, valueType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().getGlobalVarValue(cpuName, varName, bytesNum, valueType));
+            }
+            catch (error) {
+                console.error("Error during getCurrentRunningState:", error);
+                throw error;
+            }
+        });
+    }
+    getGlobalVarValueDefault(varName, valueType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cpuList = (yield this.getCpuList()).getCpuList();
+            if (cpuList != null && cpuList.length > 0) {
+                try {
+                    return yield this.call(RequestFactory_1.RequestFactory.getInstance().getGlobalVarValue(cpuList[0].getName(), varName, 4, valueType));
+                }
+                catch (error) {
+                    console.error("Error during getCurrentRunningState:", error);
+                    throw error;
+                }
+            }
+            else {
+                console.error("无法获取cpu，请确认cpu是否存在:");
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+            }
+        });
+    }
+    setGlobalVarValue(cpuName, varName, bytesNum, valueType, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().setGlobalVarValue(cpuName, varName, bytesNum, valueType, value));
+            }
+            catch (error) {
+                console.error("Error during getCurrentRunningState:", error);
+                throw error;
+            }
+        });
+    }
+    setGlobalVarValueDefault(varName, valueType, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cpuList = (yield this.getCpuList()).getCpuList();
+            if (cpuList != null && cpuList.length > 0) {
+                try {
+                    return yield this.call(RequestFactory_1.RequestFactory.getInstance().setGlobalVarValue(cpuList[0].getName(), varName, 4, valueType, value));
+                }
+                catch (error) {
+                    console.error("Error during getCurrentRunningState:", error);
+                    throw error;
+                }
+            }
+            else {
+                console.error("无法获取cpu，请确认cpu是否存在:");
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+            }
+        });
+    }
+    getMemoryValue(cpuName, baseAddr, length) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.getAddressingSpace(cpuName, baseAddr, length);
+            }
+            catch (error) {
+                console.error("Error during getMemoryValue:", error);
+                throw error;
+            }
+        });
+    }
+    getAddressingSpace(cpuName, baseAddr, length) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().getMemoryValue(cpuName, baseAddr, length));
+            }
+            catch (error) {
+                console.error("Error during getAddressingSpace:", error);
+                throw error;
+            }
+        });
+    }
+    getMemoryValueDefault(baseAddr, length) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.getAddressingSpaceDefault(baseAddr, length);
+            }
+            catch (error) {
+                console.error("Error during getMemoryValue:", error);
+                throw error;
+            }
+        });
+    }
+    getAddressingSpaceDefault(baseAddr, length) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cpuList = (yield this.getCpuList()).getCpuList();
+            if (cpuList != null && cpuList.length > 0) {
+                try {
+                    return yield this.call(RequestFactory_1.RequestFactory.getInstance().getMemoryValue(cpuList[0].getName(), baseAddr, length));
+                }
+                catch (error) {
+                    console.error("Error during getAddressingSpaceDefault:", error);
+                    throw error;
+                }
+            }
+            else {
+                console.error("无法获取cpu，请确认cpu是否存在:");
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+            }
+        });
+    }
+    getCpuRegisters(cpuName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = new GetCpuRegisterInfoResponse_1.GetCpuRegisterInfoResponse();
+            try {
+                const call = yield this.call(RequestFactory_1.RequestFactory.getInstance().getcpuRegisterInfo(cpuName));
+                if (call != null) {
+                    response.isSuccess = true;
+                    const it = call.result;
+                    it.forEach(item => {
+                        const register = new Register_1.Register(null);
+                        register.name = item.name;
+                        register.bits = item.size;
+                        register.description = item.desc;
+                        register.value = item.value;
+                        register.offset = item.offset;
+                        response.registers.push(register);
+                        response.registers.sort((r1, r2) => {
+                            if (r1.offset == null) {
+                                return 1;
+                            }
+                            if (r2.offset == null) {
+                                return -1;
+                            }
+                            if (r1.offset === r2.offset) {
+                                return 0;
+                            }
+                            return r1.offset - r2.offset > 0 ? 1 : -1;
+                        });
+                    });
+                }
+                else {
+                    throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                }
+            }
+            catch (error) {
+                console.error("Error during getCpuRegistersDefault:", error);
+                throw error;
+            }
+            return response;
+        });
+    }
+    getCpuRegistersDefault() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cpuList = (yield this.getCpuList()).getCpuList();
+            if (cpuList != null && cpuList.length > 0) {
+                try {
+                    return yield this.getCpuRegisters(cpuList[0].getName());
+                }
+                catch (error) {
+                    console.error("Error during getCpuRegistersDefault:", error);
+                    throw error;
+                }
+            }
+            else {
+                console.error("无法获取cpu，请确认cpu是否存在:");
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+            }
+        });
+    }
+    setCpuRegisterValueDefault(register, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.setCpuRegisterValue(register.getParent().getParent().getName(), register.getParent().getName(), register.getName(), value);
+            }
+            catch (error) {
+                console.error("Error during getCpuRegistersDefault:", error);
+                throw error;
+            }
+        });
+    }
+    setCpuRegisterValue(boardName, cpuName, registerName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceTree = yield this.getDeviceTree();
+            if (!deviceTree.boardMap.has(boardName)) {
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("未能找到该板卡");
+            }
+            const board = boardMap.get(boardName);
+            const deviceMap = board.getDeveceMap();
+            if (!deviceMap.has(cpuName) || !(deviceMap.get(cpuName) instanceof Cpu_1.Cpu)) {
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("未能找到该设备");
+            }
+            const cpu = deviceMap.get(cpuName);
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().setRegisterValue(cpu.getParent().getName(), cpuName, registerName, value));
+            }
+            catch (error) {
+                console.error("Error during getAddressingSpace:", error);
+                throw error;
+            }
+        });
+    }
+    getDeviceTree() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = (yield this.getCurrentRunningState()).getState();
+            if (GetRunningStateResponse_1.StateState.UNLOADED === state || GetRunningStateResponse_1.StateState.QUITED === state) {
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("当前SkyEye未加载配置，需要加载配置可以获取设备树信息，请检查当前配置");
+            }
+            const response = new GetDeviceTreeResponse_1.GetDeviceTreeResponse();
+            try {
+                const call = yield this.call(RequestFactory_1.RequestFactory.getInstance().getDeviceTree());
+                console.log("call:", call);
+                if (call.result != null) {
+                    const boardMap = ParseBoardUtils_1.ParseBoardUtils.parseBoard(call.result);
+                    response.boardMap = boardMap;
+                    response.isSuccess = true;
+                }
+                else {
+                    throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                }
+            }
+            catch (error) {
+                console.error("Error during getAddressingSpace:", error);
+                throw error;
+            }
+            return response;
+        });
+    }
+    getCurrentRunningState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = new GetRunningStateResponse_1.GetRunningStateResponse();
+            try {
+                const call = yield this.call(RequestFactory_1.RequestFactory.getInstance().getRunningStatus());
+                // { result: 2, error: null, name: 'SE_get_running_status' }
+                if (call != null) {
+                    response.isSuccess = true;
+                    switch (call.result) {
+                        case 1:
+                            response.setState(GetRunningStateResponse_1.StateState.UNLOADED);
+                            break;
+                        case 2:
+                            response.setState(GetRunningStateResponse_1.StateState.RUNNING);
+                            break;
+                        case 3:
+                            response.setState(GetRunningStateResponse_1.StateState.STOPPED);
+                            break;
+                    }
+                }
+                else {
+                    throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                }
+            }
+            catch (error) {
+                console.error("Error during getCurrentRunningState:", error);
+                throw error;
+            }
+            return response;
+        });
+    }
+    getAllDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = new GetAllDeviceInfoResponse_1.GetAllDeviceInfoResponse();
+            try {
+                const call = yield this.call(RequestFactory_1.RequestFactory.getInstance().getAllDeviceInfo());
+                if (call != null) {
+                    response.isSuccess = true;
+                    const boardMap = ParseBoardUtils_1.ParseBoardUtils.parseBoard(call.result);
+                    response.boardMap = boardMap;
+                }
+                else {
+                    throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                }
+            }
+            catch (error) {
+                console.error("Error during getCurrentRunningState:", error);
+                throw error;
+            }
+            return response;
+        });
+    }
+    getRamAddrInfo(machName, addr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = new GetRamAddrInfoResponse_1.GetRamAddrInfoResponse();
+            try {
+                const call = yield this.call(RequestFactory_1.RequestFactory.getInstance().getRamAddrInfo(machName, addr));
+                if (call.result != null) {
+                    response.isSuccess = true;
+                    response.bits = call.result.bits;
+                    response.value = call.result.value;
+                }
+                else {
+                    throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                }
+            }
+            catch (error) {
+                console.error("Error during getCurrentRunningState:", error);
+                throw error;
+            }
+            return response;
+        });
+    }
+    setRamFaultInjectDefault(device, addr, bit, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.setRamFaultInject(device.getParent().getName(), device.getName(), addr, bit, mode);
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    setRamFaultInject(boardName, deviceName, addr, bit, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().setFaultInject(boardName, deviceName, String(addr), String(bit), mode));
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    setRegisterFaultInjectDefault(register, bit, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.setRegisterFaultInject(register.getParent().getParent().getName(), register.getParent().getName(), register.baseAddr, bit, mode);
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    setRegisterFaultInject(boardName, deviceName, addr, bit, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().setFaultInject(boardName, deviceName, "0x" + String(addr), String(bit), mode));
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    deleteFaultInjectDefault(faultInjectItem) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.deleteFaultInject(faultInjectItem.boardName, faultInjectItem.deviceName, faultInjectItem.addr, String(faultInjectItem.bit), faultInjectItem.type);
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    deleteFaultInject(boardName, deviceName, addr, bit, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().deleteFaultInject(boardName, deviceName, "0x" + String(addr), String(bit), mode));
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    getFaultInjectList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = new GetFaultInjectListResponse_1.GetFaultInjectListResponse();
+            try {
+                const call = yield this.call(RequestFactory_1.RequestFactory.getInstance().getFaultInjectList());
+                if (call.result != null) {
+                    response.isSuccess = true;
+                    const items = new Array();
+                    call.result.forEach(item => {
+                        const faultInjectItem = new FaultInjectItem_1.FaultInjectItem(null);
+                        if (item != null) {
+                            faultInjectItem.deviceName = item.get(1);
+                            faultInjectItem.registerName = item.get(2);
+                            faultInjectItem.addr = item.get(3);
+                            faultInjectItem.bit = item.get(4);
+                            switch (String(item.get(5))) {
+                                case "0":
+                                    faultInjectItem.type = FaultInjectType_1.FaultInjectType.SET_ZERO;
+                                    break;
+                                case "1":
+                                    faultInjectItem.type = FaultInjectType_1.FaultInjectType.SET_ONE;
+                                    break;
+                                case "2":
+                                    faultInjectItem.type = FaultInjectType_1.FaultInjectType.SET_REVE;
+                                    break;
+                            }
+                        }
+                        items.push(faultInjectItem);
+                    });
+                    response.faultInjectItems = items;
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+            return response;
+        });
+    }
+    getDisassembleInfo(cpuName, startAddr, nums) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = new GetDisassembleInfoResponse_1.GetDisassembleInfoResponse();
+            try {
+                const call = yield this.call(RequestFactory_1.RequestFactory.getInstance().getDisassembleInfo(cpuName, startAddr, nums));
+                if (call.result != null) {
+                    response.isSuccess = true;
+                    const instructionItems = new Array();
+                    call.result.forEach(item => {
+                        const instructionItem = new InstructionItem_1.InstructionItem();
+                        instructionItem.addr = item.get(0);
+                        instructionItem.func = item.get(1);
+                        instructionItem.content = item.get(2);
+                        instructionItems.push(instructionItem);
+                    });
+                    response.instructions = instructionItems;
+                }
+                else {
+                    throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+            return response;
+        });
+    }
+    getDisassembleInfoDefault(startAddr, nums) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cpuList = (yield this.getCpuList()).getCpuList;
+            if (cpuList != null && cpuList.length > 0) {
+                return this.getDisassembleInfo(cpuList[0].name, startAddr, nums);
+            }
+            else {
+                console.error("无法获取cpu，请确认cpu是否存在:");
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+            }
+        });
+    }
+    SingleStep(cpuName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.call(RequestFactory_1.RequestFactory.getInstance().singleStep(cpuName));
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    SingleStepDefault() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cpuList = (yield this.getCpuList()).getCpuList;
+            if (cpuList != null && cpuList.length > 0) {
+                return this.SingleStep(cpuList[0].name);
+            }
+            else {
+                console.error("无法获取cpu，请确认cpu是否存在:");
+                throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+            }
+        });
+    }
+    close() {
+        super.close();
+        console.log('gRPC客户端已断开');
+        return true;
+    }
+    getHost() {
+        return this.host;
+    }
+    getPort() {
+        return this.port;
+    }
+}
+exports.SkyEyeClient = SkyEyeClient;