skyeye-sdk-js 1.0.0

package/src/SkyEyeClient.ts

@@ -0,0 +1,772 @@
+import * as grpc from '@grpc/grpc-js';
+import { JSONRequest, JSONResponse } from './proto/skyeye_rpc_pb';
+import { JSONTransmissionService, JSONTransmissionClient } from './proto/skyeye_rpc_grpc_pb';
+import { RequestFactory } from './RequestFactory';
+import { GetCpuListResponse } from './response/GetCpuListResponse';
+import { Cpu } from './models/Cpu';
+import { GlobalVarType } from './models/GlobalVarType';
+import { stringify } from 'querystring';
+import { GetDeviceListResponse } from './response/GetDeviceListResponse';
+import { GetRunningStateResponse, StateState } from './response/GetRunningStateResponse';
+import { Register } from './models/Register';
+import { GetDeviceTreeResponse } from './response/GetDeviceTreeResponse';
+import { ParseBoardUtils } from './utils/ParseBoardUtils';
+import { GetAllDeviceInfoResponse } from './response/GetAllDeviceInfoResponse';
+import { GetRamAddrInfoResponse } from './response/GetRamAddrInfoResponse';
+import { Device } from './models/Device';
+import { FaultInjectType } from './models/FaultInjectType';
+import { FaultInjectItem } from './models/FaultInjectItem';
+import { GetFaultInjectListResponse } from './response/GetFaultInjectListResponse';
+import { GetDisassembleInfoResponse } from './response/GetDisassembleInfoResponse';
+import { InstructionItem } from './models/InstructionItem';
+import { cp } from 'fs';
+import { GetCpuRegisterInfoResponse } from './response/GetCpuRegisterInfoResponse';
+import { SkyEyeSDKException } from './exception/SkyEyeSDKException';
+let client: JSONTransmissionClient | any = null;
+
+
+// ----------------------------当前运行程序的设备树----------------------------------------//
+const boardMap = new Map();
+
+
+export class SkyEyeClient extends JSONTransmissionClient {
+
+    private host: string;
+    private port: string;
+
+
+    constructor(host: string, port: string) {
+        super(host + ":" + port, grpc.credentials.createInsecure());
+        this.host = host;
+        this.port = port;
+    }
+
+    private printRequestLog(request: JSONRequest): void {
+        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))
+        }
+    }
+
+    private printResponseLog(ackObj: any): void {
+        if (ackObj != null) {
+            const name = ackObj.name;
+            if (name === "SE_get_running_status" || name === "SE_get_all_class_info") {
+                return;
+            }
+            console.log(`客户端响应-- `, ackObj);
+        }
+    }
+
+
+    public async call(request: JSONRequest) {
+        try {
+            this.printRequestLog(request)
+            const response = await new Promise<JSONResponse>((resolve, reject) => {
+                super.callSkyEye(request, (error: grpc.ServiceError | null, response: JSONResponse) => {
+                    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;
+        }
+    }
+
+
+    public async runScriptRequest(filename: string) {
+        try {
+            return await this.call(RequestFactory.getInstance().runScriptRequest(filename));
+        } catch (error) {
+            console.error("Error during runScriptRequest:", error);
+            throw error;
+        }
+    }
+
+    public async runCommand() {
+        try {
+            return await this.call(RequestFactory.getInstance().runCommand());
+        } catch (error) {
+            console.error("Error during runCommand:", error);
+            throw error;
+        }
+    }
+
+    public async stopCommand() {
+        try {
+            return await this.call(RequestFactory.getInstance().stopCommand());
+        } catch (error) {
+            console.error("Error during stopCommand:", error);
+            throw error;
+        }
+    }
+
+    public async quitCommand() {
+        try {
+            return await this.call(RequestFactory.getInstance().quitCommand());
+        } catch (error) {
+            console.error("Error during quitCommand:", error);
+            throw error;
+        }
+    }
+
+    public async getCpuList() {
+        const response = new GetCpuListResponse();
+        try {
+            const call = await this.call(RequestFactory.getInstance().getCpuList());
+            if (call != null) {
+                response.isSuccess = true;
+                if (call.result != null) {
+                    const cpuItems: Cpu[] = new Array();
+                    call.result.forEach(element => {
+                        const item = new 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(String(call.error));
+            }
+
+
+            return response;
+        } catch (error) {
+            console.error("Error during getCpuList:", error);
+            throw error;
+        }
+    }
+
+
+
+    public async enableDeviceWork(deviceName: string) {
+        try {
+            return await this.call(RequestFactory.getInstance().enableDeviceWork(deviceName));
+        } catch (error) {
+            console.error("Error during enableDeviceWork:", error);
+            throw error;
+        }
+    }
+
+
+    public async disableDeviceWork(deviceName: string) {
+        try {
+            return await this.call(RequestFactory.getInstance().disableDeviceWork(deviceName));
+        } catch (error) {
+            console.error("Error during disableDeviceWork:", error);
+            throw error;
+        }
+    }
+
+
+    public async changeDir(skyeyeProjectRootDir: string) {
+        try {
+            return await this.call(RequestFactory.getInstance().changeDir(skyeyeProjectRootDir));
+        } catch (error) {
+            console.error("Error during changeDir:", error);
+            throw error;
+        }
+    }
+
+    public async getRunningDeviceInfo() {
+        try {
+            return await this.call(RequestFactory.getInstance().getRunningDeviceInfo());
+        } catch (error) {
+            console.error("Error during getRunningDeviceInfo:", error);
+            throw error;
+        }
+    }
+
+
+    public async getSimulationTime(cpuName: string) {
+        try {
+            return await this.call(RequestFactory.getInstance().getSimulationTime(cpuName));
+        } catch (error) {
+            console.error("Error during getCurrentSimulationTime:", error);
+            throw error;
+        }
+    }
+
+
+    public async getCurrentSimulationTime() {
+        const cpuList = (await this.getCpuList()).getCpuList();
+        if (cpuList.length > 0) {
+            return this.getSimulationTime(cpuList[0].getName());
+        } else {
+            console.error("无法获取cpu，请确认cpu是否存在:");
+            throw new SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+        }
+    }
+
+
+    public async getDeviceList() {
+        const response = new GetDeviceListResponse();
+        try {
+            const call = await this.call(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: any = result;
+                    const it = Object.entries(objectNode);
+                    for (const machine of it) {
+                        const machName: string = machine[0];
+                        const devices: any = machine[1];
+                        if (typeof devices === 'object' && devices !== null) {
+                            const deviceNames = Object.keys(devices);
+                            for (const deviceName of deviceNames) {
+                                const device = new 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
+    }
+
+
+    public async getPC(cpuName: string) {
+        try {
+            return await this.call(RequestFactory.getInstance().getCurrentPC(cpuName));
+        } catch (error) {
+            console.error("Error during getPC:", error);
+            throw error;
+        }
+    }
+
+
+
+    public async getCurrentPC() {
+        const cpuList = (await this.getCpuList()).getCpuList();
+        if (cpuList != null && cpuList.length > 0) {
+            try {
+                return await this.call(RequestFactory.getInstance().getCurrentPC(cpuList[0].getName()));
+            } catch (error) {
+                console.error("Error during getCurrentPC:", error);
+                throw error;
+            }
+        } else {
+            console.error("无法获取cpu，请确认cpu是否存在:");
+            throw new SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+        }
+    }
+
+
+
+
+
+
+    public async getCpuMips(cpuName: string) {
+        try {
+            return await this.call(RequestFactory.getInstance().getCpuMips(cpuName))
+        } catch (error) {
+            console.error("Error during getCurrentRunningState:", error);
+            throw error;
+        }
+    }
+
+
+    public async getCurrentCpuMips() {
+        const cpuList = (await this.getCpuList()).getCpuList();
+        console.log("测试", cpuList[0].getName())
+        if (cpuList != null && cpuList.length > 0) {
+            try {
+
+                return await this.call(RequestFactory.getInstance().getCpuMips(cpuList[0].getName()))
+            } catch (error) {
+                console.error("Error during getCurrentRunningState:", error);
+                throw error;
+            }
+        } else {
+            console.error("无法获取cpu，请确认cpu是否存在:");
+            throw new SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+        }
+    }
+
+
+    public async getGlobalVarValue(cpuName: string, varName: string, bytesNum: number, valueType: GlobalVarType) {
+        try {
+            return await this.call(RequestFactory.getInstance().getGlobalVarValue(cpuName, varName, bytesNum, valueType))
+        } catch (error) {
+            console.error("Error during getCurrentRunningState:", error);
+            throw error;
+        }
+    }
+
+
+
+
+    public async getGlobalVarValueDefault(varName: string, valueType: GlobalVarType) {
+        const cpuList = (await this.getCpuList()).getCpuList();
+        if (cpuList != null && cpuList.length > 0) {
+            try {
+                return await this.call(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("无法获取cpu，请确认cpu是否存在:");
+        }
+    }
+
+
+
+
+
+    public async setGlobalVarValue(cpuName: string, varName: string, bytesNum: number, valueType: GlobalVarType, value: string) {
+        try {
+            return await this.call(RequestFactory.getInstance().setGlobalVarValue(cpuName, varName, bytesNum, valueType, value))
+        } catch (error) {
+            console.error("Error during getCurrentRunningState:", error);
+            throw error;
+        }
+    }
+
+    public async setGlobalVarValueDefault(varName: string, valueType: GlobalVarType, value: string) {
+        const cpuList = (await this.getCpuList()).getCpuList();
+        if (cpuList != null && cpuList.length > 0) {
+            try {
+                return await this.call(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("无法获取cpu，请确认cpu是否存在:");
+        }
+    }
+
+
+    public async getMemoryValue(cpuName: string, baseAddr: number, length: number) {
+        try {
+            return this.getAddressingSpace(cpuName, baseAddr, length);
+        } catch (error) {
+            console.error("Error during getMemoryValue:", error);
+            throw error;
+        }
+    }
+
+
+    public async getAddressingSpace(cpuName: string, baseAddr: number, length: number) {
+        try {
+            return await this.call(RequestFactory.getInstance().getMemoryValue(cpuName, baseAddr, length));
+        } catch (error) {
+            console.error("Error during getAddressingSpace:", error);
+            throw error;
+        }
+    }
+
+
+
+    public async getMemoryValueDefault(baseAddr: number, length: number) {
+        try {
+            return this.getAddressingSpaceDefault(baseAddr, length);
+        } catch (error) {
+            console.error("Error during getMemoryValue:", error);
+            throw error;
+        }
+    }
+
+
+    public async getAddressingSpaceDefault(baseAddr: number, length: number) {
+        const cpuList = (await this.getCpuList()).getCpuList();
+        if (cpuList != null && cpuList.length > 0) {
+            try {
+                return await this.call(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("无法获取cpu，请确认cpu是否存在:");
+        }
+    }
+
+
+    public async getCpuRegisters(cpuName: string) {
+        const response = new GetCpuRegisterInfoResponse();
+        try {
+            const call = await this.call(RequestFactory.getInstance().getcpuRegisterInfo(cpuName));
+            if (call != null) {
+                response.isSuccess = true;
+                const it = call.result;
+                it.forEach(item => {
+                    const register = new 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(String(call.error));
+            }
+        } catch (error) {
+            console.error("Error during getCpuRegistersDefault:", error);
+            throw error;
+        }
+        return response;
+    }
+
+
+    public async getCpuRegistersDefault() {
+        const cpuList = (await this.getCpuList()).getCpuList();
+        if (cpuList != null && cpuList.length > 0) {
+            try {
+                return await this.getCpuRegisters(cpuList[0].getName());
+            } catch (error) {
+                console.error("Error during getCpuRegistersDefault:", error);
+                throw error;
+            }
+        } else {
+            console.error("无法获取cpu，请确认cpu是否存在:");
+            throw new SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+        }
+    }
+
+
+    public async setCpuRegisterValueDefault(register: Register, value: number) {
+        try {
+            return await this.setCpuRegisterValue(register.getParent().getParent().getName(), register.getParent().getName(), register.getName(), value);
+        } catch (error) {
+            console.error("Error during getCpuRegistersDefault:", error);
+            throw error;
+        }
+    }
+
+
+    public async setCpuRegisterValue(boardName: string, cpuName: string, registerName: string, value: number) {
+        const deviceTree = await this.getDeviceTree();
+        if (!deviceTree.boardMap.has(boardName)) {
+            throw new SkyEyeSDKException("未能找到该板卡");
+        }
+        const board = boardMap.get(boardName);
+        const deviceMap = board.getDeveceMap();
+        if (!deviceMap.has(cpuName) || !(deviceMap.get(cpuName) instanceof Cpu)) {
+            throw new SkyEyeSDKException("未能找到该设备");
+        }
+        const cpu = deviceMap.get(cpuName);
+        try {
+            return await this.call(RequestFactory.getInstance().setRegisterValue(cpu.getParent().getName(), cpuName, registerName, value));
+        } catch (error) {
+            console.error("Error during getAddressingSpace:", error);
+            throw error;
+        }
+    }
+
+
+    public async getDeviceTree() {
+        const state = (await this.getCurrentRunningState()).getState();
+        if (StateState.UNLOADED === state || StateState.QUITED === state) {
+            throw new SkyEyeSDKException("当前SkyEye未加载配置，需要加载配置可以获取设备树信息，请检查当前配置")
+        }
+        const response = new GetDeviceTreeResponse();
+        try {
+            const call = await this.call(RequestFactory.getInstance().getDeviceTree());
+            console.log("call:", call)
+            if (call.result != null) {
+                const boardMap = ParseBoardUtils.parseBoard(call.result);
+                response.boardMap = boardMap;
+                response.isSuccess = true;
+            } else {
+                throw new SkyEyeSDKException(String(call.error));
+            }
+        } catch (error) {
+            console.error("Error during getAddressingSpace:", error);
+            throw error;
+        }
+        return response;
+    }
+
+
+
+    public async getCurrentRunningState() {
+        const response = new GetRunningStateResponse();
+        try {
+            const call = await this.call(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(StateState.UNLOADED);
+                        break;
+                    case 2:
+                        response.setState(StateState.RUNNING);
+                        break;
+                    case 3:
+                        response.setState(StateState.STOPPED);
+                        break;
+                }
+            } else {
+                throw new SkyEyeSDKException(String(call.error));
+            }
+        } catch (error) {
+            console.error("Error during getCurrentRunningState:", error);
+            throw error;
+        }
+        return response;
+    }
+
+
+
+    public async getAllDeviceInfo() {
+        const response = new GetAllDeviceInfoResponse();
+        try {
+            const call = await this.call(RequestFactory.getInstance().getAllDeviceInfo());
+            if (call != null) {
+                response.isSuccess = true;
+                const boardMap = ParseBoardUtils.parseBoard(call.result);
+                response.boardMap = boardMap;
+            } else {
+                throw new SkyEyeSDKException(String(call.error));
+            }
+        } catch (error) {
+            console.error("Error during getCurrentRunningState:", error);
+            throw error;
+        }
+        return response;
+    }
+
+
+    public async getRamAddrInfo(machName: string, addr: number) {
+        const response = new GetRamAddrInfoResponse();
+        try {
+            const call = await this.call(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(String(call.error));
+            }
+        } catch (error) {
+            console.error("Error during getCurrentRunningState:", error);
+            throw error;
+        }
+        return response;
+    }
+
+
+    public async setRamFaultInjectDefault(device: Device, addr: number, bit: number, mode: FaultInjectType) {
+        try {
+            return await this.setRamFaultInject(device.getParent().getName(), device.getName(), addr, bit, mode);
+        } catch (error) {
+            throw error;
+        }
+    }
+
+
+
+    public async setRamFaultInject(boardName: string, deviceName: string, addr: number, bit: number, mode: FaultInjectType) {
+        try {
+            return await this.call(RequestFactory.getInstance().setFaultInject(boardName, deviceName, String(addr), String(bit), mode))
+        } catch (error) {
+            throw error;
+        }
+    }
+
+
+
+    public async setRegisterFaultInjectDefault(register: Register, bit: number, mode: FaultInjectType) {
+        try {
+            return await this.setRegisterFaultInject(register.getParent().getParent().getName(), register.getParent().getName(), register.baseAddr, bit, mode)
+        } catch (error) {
+            throw error;
+        }
+    }
+
+
+    public async setRegisterFaultInject(boardName: string, deviceName: string, addr: number, bit: number, mode: FaultInjectType) {
+        try {
+            return await this.call(RequestFactory.getInstance().setFaultInject(boardName, deviceName, "0x" + String(addr), String(bit), mode))
+        } catch (error) {
+            throw error;
+        }
+    }
+ 
+
+    public async deleteFaultInjectDefault(faultInjectItem: FaultInjectItem) {
+        try {
+            return await this.deleteFaultInject(faultInjectItem.boardName, faultInjectItem.deviceName,
+                faultInjectItem.addr, String(faultInjectItem.bit),
+                faultInjectItem.type);
+        } catch (error) {
+            throw error;
+        }
+    }
+
+
+    public async deleteFaultInject(boardName: string, deviceName: string, addr: number, bit: string, mode: FaultInjectType) {
+        try {
+            return await this.call(RequestFactory.getInstance().deleteFaultInject(boardName, deviceName, "0x" + String(addr), String(bit), mode))
+        } catch (error) {
+            throw error;
+        }
+    }
+
+
+    public async getFaultInjectList() {
+        const response = new GetFaultInjectListResponse();
+        try {
+            const call = await this.call(RequestFactory.getInstance().getFaultInjectList());
+            if (call.result != null) {
+                response.isSuccess = true;
+                const items = new Array();
+                call.result.forEach(item => {
+                    const faultInjectItem = new 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.SET_ZERO
+                                break;
+                            case "1":
+                                faultInjectItem.type = FaultInjectType.SET_ONE
+                                break;
+                            case "2":
+                                faultInjectItem.type = FaultInjectType.SET_REVE
+                                break;
+                        }
+                    }
+                    items.push(faultInjectItem)
+                })
+                response.faultInjectItems = items;
+            }
+        } catch (error) {
+            throw error;
+        }
+        return response;
+    }
+
+
+    public async getDisassembleInfo(cpuName: string, startAddr: number, nums: number) {
+        const response = new GetDisassembleInfoResponse();
+        try {
+            const call = await this.call(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();
+                    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(String(call.error));
+            }
+        } catch (error) {
+            throw error;
+        }
+        return response;
+    }
+
+
+    public async getDisassembleInfoDefault(startAddr: number, nums: number) {
+        const cpuList = (await 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("无法获取cpu，请确认cpu是否存在:");
+        }
+    }
+
+
+
+    public async SingleStep(cpuName: string) {
+        try {
+            return await this.call(RequestFactory.getInstance().singleStep(cpuName))
+        } catch (error) {
+            throw error;
+        }
+    }
+
+
+    public async SingleStepDefault() {
+        const cpuList = (await this.getCpuList()).getCpuList;
+        if (cpuList != null && cpuList.length > 0) {
+            return this.SingleStep(cpuList[0].name);
+        } else {
+            console.error("无法获取cpu，请确认cpu是否存在:");
+            throw new SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+        }
+    }
+
+
+    public close(): boolean {
+        super.close();
+        console.log('gRPC客户端已断开');
+        return true;
+    }
+
+
+    public getHost() {
+        return this.host;
+    }
+
+    public getPort() {
+        return this.port;
+    }
+
+}