skyeye-sdk-js 1.4.14 → 1.4.15

package/test.ts

@@ -1,18 +1,22 @@
-import { JSONResponse } from "./src/proto/skyeye_rpc_pb";
-import { GrpcUtil } from "./src/GrpcUtil";
-import { ServiceError } from "@grpc/grpc-js";
-import { Enum } from "protobufjs";
+// import { JSONResponse } from "./src/proto/skyeye_rpc_pb";
+// import { GrpcUtil } from "./src/GrpcUtil";
+// import { ServiceError } from "@grpc/grpc-js";
+// import { Enum } from "protobufjs";
+
+// import { write } from "fs";
+// import { SkyEyeClientFactory } from "src/SkyEyeClientFactory";
+import { Readable, Transform } from "stream";
 
 const { SkyEyeClientFactory } = require('./src/SkyEyeClientFactory')
-const { SkyEyeClient } = require('./src/SkyEyeClient')
+// const { SkyEyeClient } = require('./src/SkyEyeClient')
 
-const { Cpu } = require('./src/models/Cpu')
+// const { Cpu } = require('./src/models/Cpu')
 
-enum RegisterType {
-    CPU,
-    Device
-}
-let call
+// enum RegisterType {
+//     CPU,
+//     Device
+// }
+// let call
 async function test() {
     // console.log("Connected to SkyEye server");
     // await client.getDeviceList();
@@ -57,16 +61,24 @@ async function test() {
     // const skyeyeDir = "D:/install/SkyEye/opt/skyeye/bin/skyeye.exe"
     // const port = "50066"
 
-    const pathSkyEye = "C:/Users/lingt/Downloads/SkyTest_Double";
-    const fileName = "C:/Users/lingt/Downloads/SkyTest_Double/SkyTest_Double.skyeye";
+    const pathSkyEye = "C:/Users/lingt/Downloads/SkyTest_Double_rm_28335";
+    const fileName = "C:/Users/lingt/Downloads/SkyTest_Double_rm_28335/SkyTest_Double.skyeye";
     const skyeyeDir = "G:/SkyEye/opt/skyeye/bin/skyeye.exe"
     const port = "50051"
     // const client = await SkyEyeClientFactory.instance.createConnectedClient('127.0.0.1', port);
-    const client = SkyEyeClientFactory.instance.createClient('127.0.0.1', port);
+    const client =  SkyEyeClientFactory.instance.createClient('127.0.0.1', port);
     const t = await client.initSkyEyeAndRun2(pathSkyEye, fileName, port, skyeyeDir)
-    //   await client.runCommand();
-    const response = await client.getDeviceTree()
-    console.log(response)
+    await client.runCommand();
+    setTimeout(async () => {
+        await client.stopCommand();
+         let response = await client.getGlobalVarValue("c67x_core_0","li1", 8, "int")
+          console.log(response)
+          response = await client.setGlobalVarValue("c67x_core_0","li1", 8, "int","1234567890123456789")
+          console.log(response)
+          response = await client.getGlobalVarValue("c67x_core_0","li1", 8, "int")
+          console.log(response)
+    }, 3000);
+   
     // await client.registerTimeMonitor({
     // "id": "1",
     // "time": 50,
@@ -115,4 +127,409 @@ async function test() {
 // { name: 'SE_get_cpu_freq_hz', result: 200000000, error: null }
     
 }
-test()
+test()
+// const protobuf = require("protobufjs");
+// const root = protobuf.loadSync("./src/proto/line_chart.proto");
+// const Series = root.lookupType("Series");
+// // const { UserData } = require('.src/proto/line_chart_pb'); // 预编译生成
+// // const fs = require('fs');
+
+// // JSON对象数据
+// const jsonData = {
+//   series: [
+//   ],
+//   time: [
+
+//   ]
+// };
+
+// for (let i = 0; i < 50; i++) {
+//     jsonData.series.push({
+//         name: 'test' + i,
+//         value: []
+//     })
+// }
+// function getRandomDouble(min, max) {
+//   return Math.random() * (max - min) + min;
+// }
+// function getRandomInt(max) {
+//   return Math.floor(Math.random() * max);
+// }
+// jsonData.series.forEach((item, index) => {
+//     for (let i = 0; i < 300; i++) {
+//         item.value.push(getRandomDouble(0,10000))
+//     }
+// })
+// for (let i = 0; i < 300; i++) {
+//     jsonData.time.push({
+//         "realTime": getRandomDouble(0, 10000),
+//         "simulationTime": getRandomDouble(0, 10000),
+//         "customTime": getRandomDouble(0, 10000),
+//     })
+// }
+
+// console.log(jsonData.series.length)
+// console.log(jsonData.series[0].value.length)
+// // function getSerializedSize(obj) {
+// //   const jsonString = JSON.stringify(obj);
+// //   return Buffer.byteLength(jsonString, 'utf8'); // 精确计算 UTF-8 字节数
+// // }
+// // console.log(getSerializedSize(jsonData))
+// // 序列化为Protobuf二进制Buffer
+// // const d1 = new Date();
+// // const protoBuffer = Series.encode(Series.create(jsonData)).finish();
+// // const d2 = new Date();
+// // console.log("序列化时间:", (d2.getTime() - d1.getTime()) / 1000);
+// // const zlib = require("zlib");
+
+// // // Gzip压缩（同步示例）
+// // const compressedData = zlib.gzipSync(protoBuffer);
+// // const d3 = new Date();
+// // console.log("压缩时间:", (d3.getTime() - d2.getTime()) / 1000);
+// // const fs = require("fs");
+// // const outputStream = fs.createWriteStream('test.dat');
+// // outputStream.write(compressedData);
+// // const d4 = new Date();
+// // console.log("存储时间:", (d4.getTime() - d3.getTime()) / 1000);
+// // console.log("压缩数据已存储");
+
+// // const zlib = require("zlib");
+// // const fs = require("fs");
+// // const { pipeline } = require('stream');
+// // const path = require("path");
+// // const d1 = new Date();
+// // // 1. 创建转换流：JSON → Protobuf 二进制
+// // const buffer = Series.encode(Series.create(jsonData)).finish();
+// // console.log('压缩')
+// // // 2. 创建压缩流（Brotli 高压缩率）
+// // const compress = zlib.createGzip({ level: 9 })
+// // const writeStream = fs.createWriteStream( "test.dat"); // 1MB 缓冲区
+
+// //   // 5. 管道连接：序列化数据 → 压缩 → 写入文件
+// //   const dataStream = require("stream").Readable.from(buffer); // 将 Buffer 转为可读流
+// //   dataStream
+// //     .pipe(compress)        // 压缩数据
+// //     .pipe(writeStream)  // 写入文件
+// //     .on("finish", () => {
+// //         const d2 = new Date();
+// //         console.log("序列化时间:", (d2.getTime() - d1.getTime()) / 1000);
+// //         console.log("数据已压缩存储成功")
+// //     })
+// //     .on("error", (err) => console.error("❌ 写入失败:", err));
+
+// // const compressedInput = fs.readFileSync("user.dat");
+// // const decompressedData = zlib.gunzipSync(compressedInput);
+// // const decodedProto = Series.decode(decompressedData);
+// // const originalJson = Series.toObject(decodedProto, { arrays: true }); // 保留数组类型
+// // // console.log("还原的JSON:", originalJson);
+// // console.log("还原的JSON:", originalJson.series[0].data[0]);
+
+
+
+// const zlib = require("zlib");
+// const fs = require("fs");
+
+// class SplitFileWriter  {
+//   constructor() {
+//     this.currentFile = null;
+//     this.currentSize = 0;
+//     this.fileIndex = 0;
+//     this.filename = `test_111.dat`;
+//     this.fd = null;
+//     this.createNewFile();
+//   }
+
+//    createNewFile() {
+    
+//     if (this.currentFile) this.currentFile.end();
+    
+//     this.currentFile = fs.createWriteStream(this.filename,{flags: 'a', start: 4 });
+//     this.currentSize = 0;
+//   }
+
+//   async writeHeader() {
+//      // 1. 读取并修改前4字节整数
+//     const readStream = fs.createReadStream(this.filename, { start: 0, end: 3 });
+//     let headerBuffer = Buffer.alloc(0);
+
+//     // 收集前4字节数据
+//     readStream.on('data', (chunk) => {
+//       headerBuffer = Buffer.concat([headerBuffer, chunk]);
+//     });
+
+//     // 等待头部读取完成
+//     await new Promise((resolve, reject) => {
+//       readStream.on('end', resolve);
+//       readStream.on('error', reject);
+//     });
+
+//     const newHeaderBuffer = Buffer.alloc(4);
+//     console.log(headerBuffer)
+//     if (headerBuffer.length < 4) {
+//       newHeaderBuffer.writeUInt32BE(0);
+//     } else {
+//        // 解析为整数并修改（小端序）
+//       const originalInt = headerBuffer.readUInt32BE();
+//       const modifiedInt = originalInt + 1;
+//       newHeaderBuffer.writeUInt32BE(modifiedInt);
+//     }
+//     console.log(newHeaderBuffer.readUint32BE());
+//     const compressedData = zlib.gzipSync(newHeaderBuffer)
+//     console.log(compressedData)
+    
+//     // 2. 修改文件头部（覆盖写入前4字节）
+//     const writeHeaderStream = fs.createWriteStream(this.filename, { flags: 'r+', start: 0, end:3 });
+//     writeHeaderStream.write(newHeaderBuffer);
+//     await new Promise((resolve) => writeHeaderStream.end(resolve));
+//   }
+
+//   async write(chunk) {
+//     // 100MB限制（含压缩后数据）
+
+//     if (this.currentSize + chunk.length > 1000 * 1024 * 1024 ) {
+      
+//       await this.createNewFile();
+      
+//     }
+//     if(this.currentSize === 0) {
+//       await this.writeHeader()
+      
+//     }
+
+//     this.currentFile.write(chunk, 'binary',async ()=>{
+//         const fd = this.currentFile.fd;
+//         fs.fsyncSync(fd);
+//         await this.writeHeader()
+//         date2 = new Date()
+//         console.log('存储时间:', (date2.getTime() - date1.getTime()) / 1000);
+//     });
+    
+//     this.currentSize += chunk.length;
+//   }
+// }
+
+// // 3. 每30秒处理数据的管道
+// const writer = new SplitFileWriter()
+
+
+// function handleData(data) {
+//   let temp = {
+//     series: [],
+//     time: []}
+//   temp.series =data.series.map(series => {
+//     return {
+//       name: series.name,
+//       value: series.value.map(value => {
+//       return handleDataValue(value)
+//     })
+//     }
+//   })
+
+//   temp.time.map(time => {
+//     time.customTime = handleDataValue(time.customTime)
+//     time.realTime = handleDataValue(time.realTime)
+//     time.simulationTime = handleDataValue(time.simulationTime)
+//   })
+
+//   return temp
+// }
+
+// function handleDataValue(value) {
+//   if (typeof value === 'string') {
+//     return {
+//       type: 'str',
+//       stringValue: value
+//     }
+//   } else if (typeof value === 'number') {
+//     if (Number.isInteger(value)) {
+//       return {
+//         type: 'int',
+//         intValue: value
+//       }
+//     } else {
+//       return {
+//         type: 'dbl',
+//         doubleValue: value
+//       }
+//     }
+//   } else {
+//     return {
+//       type: 'str',
+//       stringValue: 'undefined'
+//     }
+//   }
+// }
+// // let date1 = new Date();
+// // let date2 = new Date();
+// // const handled = handleData(jsonData)
+// // setInterval(async () => {
+// //   console.log('下一次循环')
+// //   date1 = new Date()
+// //   const chunk = Series.create(handled);
+// //   const serialized = Series.encode(chunk).finish();
+  
+// //   // 4. 创建带长度头的消息（解决边界问题）
+// //   const header = Buffer.alloc(4);
+// //   header.writeUInt32BE(serialized.length);
+// //   const dataWithHeader = Buffer.concat([header, serialized]);
+// //   const compressedData = zlib.gzipSync(dataWithHeader);
+// //   await writer.write(compressedData)
+// // }, 5000);
+
+
+
+// function readAndProcessGzip(filePath) {
+//     try {
+//         // 1. 同步读取GZIP压缩文件
+//         let compressedData = fs.readFileSync(filePath);
+//         const header = Buffer.from(compressedData, 0, 4);
+//         compressedData = compressedData.subarray(4);
+//         const chunkSize = header.readUInt32BE();
+//         // 2. 同步解压GZIP数据
+//         let decompressedData = zlib.gunzipSync(compressedData);
+//         // console.log(decompressedData)
+//         // 3. 分块解析数据（假设格式为：[4字节长度头] + [序列化数据]）
+//         let offset = 0;
+//         const chunks = [];
+//         console.log(decompressedData.length)
+        
+//         console.log('chunkSize',chunkSize)
+        
+//         while (offset < decompressedData.length) {
+//             // 3.1 检查长度头完整性（需4字节）
+//             if (offset + 4 > decompressedData.length) {
+//                 throw new Error("Incomplete header at end of file");
+//             }
+
+//             // 3.2 读取消息长度（大端序）
+//             const msgLength = decompressedData.readUInt32BE(offset);
+//             offset += 4;
+
+//             // 3.3 检查消息体完整性
+//             // if (offset + msgLength > decompressedData.length) {
+//             //     throw new Error(`Incomplete data: expected ${msgLength} bytes, got ${decompressedData.length - offset}`);
+//             // }
+
+//             // 3.4 提取单条消息的Buffer
+//             const msgBuffer = decompressedData.slice(offset, msgLength + offset);
+//             decompressedData = decompressedData.slice(msgLength + offset);
+//             offset= 0;
+
+//             chunks.push(msgBuffer);
+//         }
+
+//         return chunks; // 返回解析后的Buffer数组
+//     } catch (err) {
+//         console.error("Processing failed:", err);
+//         throw err; // 向上抛出异常
+//     }
+// }
+
+// // // 使用示例
+// // const filePath = 'test_111.dat';
+// // // const filePath = 'test_1755569497065_0.dat';
+// // const date1 = new Date()
+// // const parsedChunks = readAndProcessGzip(filePath);
+// // const date2 = new Date()
+// // console.log("读取时间:", (date2.getTime() - date1.getTime()) / 1000);
+// // console.log(`Parsed ${parsedChunks.length} chunks`);
+
+// // parsedChunks.forEach((buf, i) => {
+// //   // console.log(buf)
+// //     const decoded = Series.decode(buf);
+// //     console.log('读取数据长度:', decoded.series[0].value.length);
+// //     console.log('读取数据第一个数据:', decoded.series[0].value[0]);
+
+// //     console.log('读取数据:', decoded.time[0]);
+// // });
+
+// // console.log('处理时间:', (new Date().getTime() - date2.getTime()) / 1000);
+
+// const filePath = 'G:\\testchunk\\双板测试通讯_线性图_Z2ooQ_20250827_150827.dat';
+// const { pipeline } = require('stream');
+// const readHeaderStream = fs.createReadStream(filePath,{start:0, end:3});
+// let headerBuffer = Buffer.alloc(0);
+
+// // 收集前4字节数据
+// readHeaderStream.on('data', (chunk) => {
+//   headerBuffer = Buffer.concat([headerBuffer, chunk]);
+//   console.log('chunkkkkkkSize',headerBuffer.readUInt32BE())
+// });
+
+// // 等待头部读取完成
+
+// const readStream = fs.createReadStream(filePath,{start:4});
+// // 2. 创建解压流（Gunzip）
+// const gunzipStream = zlib.createGunzip();
+// // 3. 初始化数组存储解压后的数据块
+
+// const decompressedData = Buffer.alloc(0)
+
+// const chunks = [];
+// // 4. 监听解压流的数据事件，收集数据块
+// class ChunkProcessor extends Transform {
+//   constructor(decompressedData) {
+//     super();
+//     this.arr = decompressedData
+//   }
+
+//   _transform(chunk, encoding, callback) {
+//     // 将当前 chunk 加入阻塞队列
+//     // console.log(chunk.length)
+//     // console.log(this.arr)
+//     try {
+//       this.arr = Buffer.concat([this.arr, chunk]);
+//       let offset = 0;
+//       while (offset <= this.arr.length) {
+//       // 3.1 检查长度头完整性（需4字节）
+//       if (offset + 4 > this.arr.length) {
+//           break
+//       }
+
+//       // 3.2 读取消息长度（大端序）
+//       const msgLength = this.arr.readUInt32BE(offset);
+//       offset += 4;
+//       // console.log(msgLength)
+//       // 3.3 检查消息体完整性
+//       if (offset + msgLength > this.arr.length) {
+//           break;
+//       }
+
+//       // 3.4 提取单条消息的Buffer
+//       const msgBuffer = this.arr.slice(offset, msgLength + offset);
+//       this.arr = this.arr.slice(msgLength + offset);
+//       offset= 0;
+//       // console.log(msgBuffer.length)
+//       chunks.push(msgBuffer);
+      
+//       }
+//       callback();
+//     }  catch (err) {
+//         console.error("Pipeline error:", err);
+//         callback(err);
+//     }  
+//   }
+// }
+
+
+// readStream.pipe(gunzipStream).pipe(new ChunkProcessor(decompressedData)).on('error', err => console.error('Pipeline error:', err)).on('finish', () => {
+//   console.log('读取chunk个:', chunks.length);  
+//   let sum = 0
+//   chunks.forEach((buf, i) => {
+//     // console.log(buf)
+//       const decoded = Series.decode(buf);
+    
+//       decoded.series.forEach((item, index) => {
+//         console.log(item.value[item.value.length - 1].intValue)
+//       })
+//       console.log('读取数据长度:', decoded.series[0].value.length);
+//       sum += decoded.series[0].value.length
+//       // console.log('读取数据第一个数据:', decoded.series[0].value[0]);
+
+//       // console.log('读取数据:', decoded.time[0]);
+//   });
+//   console.log('读取数据总长度:', sum);
+
+// });
+
+