feat: 添加示波器前后端

src/APIClient.ts

@@ -3170,6 +3170,61 @@ export class NetConfigClient {
         return Promise.resolve<boolean>(null as any);
     }
 
+    /**
+     * 设置板卡MAC地址
+     * @param boardMac (optional) 板卡MAC地址（格式：AA:BB:CC:DD:EE:FF）
+     * @return 操作结果
+     */
+    setBoardMAC(boardMac: string | undefined): Promise<boolean> {
+        let url_ = this.baseUrl + "/api/NetConfig/SetBoardMAC?";
+        if (boardMac === null)
+            throw new Error("The parameter 'boardMac' cannot be null.");
+        else if (boardMac !== undefined)
+            url_ += "boardMac=" + encodeURIComponent("" + boardMac) + "&";
+        url_ = url_.replace(/[?&]$/, "");
+
+        let options_: RequestInit = {
+            method: "POST",
+            headers: {
+                "Accept": "application/json"
+            }
+        };
+
+        return this.http.fetch(url_, options_).then((_response: Response) => {
+            return this.processSetBoardMAC(_response);
+        });
+    }
+
+    protected processSetBoardMAC(response: Response): Promise<boolean> {
+        const status = response.status;
+        let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+            let result200: any = null;
+            let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = resultData200 !== undefined ? resultData200 : <any>null;
+    
+            return result200;
+            });
+        } else if (status === 400) {
+            return response.text().then((_responseText) => {
+            let result400: any = null;
+            let resultData400 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result400 = ProblemDetails.fromJS(resultData400);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result400);
+            });
+        } else if (status === 500) {
+            return response.text().then((_responseText) => {
+            return throwException("A server side error occurred.", status, _responseText, _headers);
+            });
+        } else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+            return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve<boolean>(null as any);
+    }
+
     /**
      * 设置主机MAC地址
      * @param hostMac (optional) 主机MAC地址（格式：AA:BB:CC:DD:EE:FF）
@@ -3319,31 +3374,81 @@ export class NetConfigClient {
     }
 
     /**
-     * 设置板卡MAC地址
-     * @param boardMac (optional) 板卡MAC地址（格式：AA:BB:CC:DD:EE:FF）
-     * @return 操作结果
+     * 获取本机网络信息
+     * @return 本机网络信息
      */
-    setBoardMAC(boardMac: string | undefined): Promise<boolean> {
-        let url_ = this.baseUrl + "/api/NetConfig/SetBoardMAC?";
-        if (boardMac === null)
-            throw new Error("The parameter 'boardMac' cannot be null.");
-        else if (boardMac !== undefined)
-            url_ += "boardMac=" + encodeURIComponent("" + boardMac) + "&";
+    getLocalNetworkInfo(): Promise<any> {
+        let url_ = this.baseUrl + "/api/NetConfig/GetLocalNetworkInfo";
         url_ = url_.replace(/[?&]$/, "");
 
         let options_: RequestInit = {
-            method: "POST",
+            method: "GET",
             headers: {
                 "Accept": "application/json"
             }
         };
 
         return this.http.fetch(url_, options_).then((_response: Response) => {
-            return this.processSetBoardMAC(_response);
+            return this.processGetLocalNetworkInfo(_response);
         });
     }
 
-    protected processSetBoardMAC(response: Response): Promise<boolean> {
+    protected processGetLocalNetworkInfo(response: Response): Promise<any> {
+        const status = response.status;
+        let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+            let result200: any = null;
+            let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = resultData200 !== undefined ? resultData200 : <any>null;
+    
+            return result200;
+            });
+        } else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+            return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve<any>(null as any);
+    }
+}
+
+export class OscilloscopeApiClient {
+    private http: { fetch(url: RequestInfo, init?: RequestInit): Promise<Response> };
+    private baseUrl: string;
+    protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;
+
+    constructor(baseUrl?: string, http?: { fetch(url: RequestInfo, init?: RequestInit): Promise<Response> }) {
+        this.http = http ? http : window as any;
+        this.baseUrl = baseUrl ?? "http://localhost:5000";
+    }
+
+    /**
+     * 初始化示波器
+     * @param config 示波器配置
+     * @return 操作结果
+     */
+    initialize(config: OscilloscopeFullConfig): Promise<boolean> {
+        let url_ = this.baseUrl + "/api/OscilloscopeApi/Initialize";
+        url_ = url_.replace(/[?&]$/, "");
+
+        const content_ = JSON.stringify(config);
+
+        let options_: RequestInit = {
+            body: content_,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Accept": "application/json"
+            }
+        };
+
+        return this.http.fetch(url_, options_).then((_response: Response) => {
+            return this.processInitialize(_response);
+        });
+    }
+
+    protected processInitialize(response: Response): Promise<boolean> {
         const status = response.status;
         let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
         if (status === 200) {
@@ -3365,6 +3470,374 @@ export class NetConfigClient {
             return response.text().then((_responseText) => {
             return throwException("A server side error occurred.", status, _responseText, _headers);
             });
+        } else if (status === 401) {
+            return response.text().then((_responseText) => {
+            let result401: any = null;
+            let resultData401 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result401 = ProblemDetails.fromJS(resultData401);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result401);
+            });
+        } else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+            return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve<boolean>(null as any);
+    }
+
+    /**
+     * 启动捕获
+     * @return 操作结果
+     */
+    startCapture(): Promise<boolean> {
+        let url_ = this.baseUrl + "/api/OscilloscopeApi/StartCapture";
+        url_ = url_.replace(/[?&]$/, "");
+
+        let options_: RequestInit = {
+            method: "POST",
+            headers: {
+                "Accept": "application/json"
+            }
+        };
+
+        return this.http.fetch(url_, options_).then((_response: Response) => {
+            return this.processStartCapture(_response);
+        });
+    }
+
+    protected processStartCapture(response: Response): Promise<boolean> {
+        const status = response.status;
+        let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+            let result200: any = null;
+            let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = resultData200 !== undefined ? resultData200 : <any>null;
+    
+            return result200;
+            });
+        } else if (status === 400) {
+            return response.text().then((_responseText) => {
+            let result400: any = null;
+            let resultData400 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result400 = ProblemDetails.fromJS(resultData400);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result400);
+            });
+        } else if (status === 500) {
+            return response.text().then((_responseText) => {
+            return throwException("A server side error occurred.", status, _responseText, _headers);
+            });
+        } else if (status === 401) {
+            return response.text().then((_responseText) => {
+            let result401: any = null;
+            let resultData401 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result401 = ProblemDetails.fromJS(resultData401);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result401);
+            });
+        } else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+            return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve<boolean>(null as any);
+    }
+
+    /**
+     * 停止捕获
+     * @return 操作结果
+     */
+    stopCapture(): Promise<boolean> {
+        let url_ = this.baseUrl + "/api/OscilloscopeApi/StopCapture";
+        url_ = url_.replace(/[?&]$/, "");
+
+        let options_: RequestInit = {
+            method: "POST",
+            headers: {
+                "Accept": "application/json"
+            }
+        };
+
+        return this.http.fetch(url_, options_).then((_response: Response) => {
+            return this.processStopCapture(_response);
+        });
+    }
+
+    protected processStopCapture(response: Response): Promise<boolean> {
+        const status = response.status;
+        let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+            let result200: any = null;
+            let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = resultData200 !== undefined ? resultData200 : <any>null;
+    
+            return result200;
+            });
+        } else if (status === 400) {
+            return response.text().then((_responseText) => {
+            let result400: any = null;
+            let resultData400 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result400 = ProblemDetails.fromJS(resultData400);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result400);
+            });
+        } else if (status === 500) {
+            return response.text().then((_responseText) => {
+            return throwException("A server side error occurred.", status, _responseText, _headers);
+            });
+        } else if (status === 401) {
+            return response.text().then((_responseText) => {
+            let result401: any = null;
+            let resultData401 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result401 = ProblemDetails.fromJS(resultData401);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result401);
+            });
+        } else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+            return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve<boolean>(null as any);
+    }
+
+    /**
+     * 获取示波器数据和状态
+     * @return 示波器数据和状态信息
+     */
+    getData(): Promise<OscilloscopeDataResponse> {
+        let url_ = this.baseUrl + "/api/OscilloscopeApi/GetData";
+        url_ = url_.replace(/[?&]$/, "");
+
+        let options_: RequestInit = {
+            method: "GET",
+            headers: {
+                "Accept": "application/json"
+            }
+        };
+
+        return this.http.fetch(url_, options_).then((_response: Response) => {
+            return this.processGetData(_response);
+        });
+    }
+
+    protected processGetData(response: Response): Promise<OscilloscopeDataResponse> {
+        const status = response.status;
+        let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+            let result200: any = null;
+            let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result200 = OscilloscopeDataResponse.fromJS(resultData200);
+            return result200;
+            });
+        } else if (status === 400) {
+            return response.text().then((_responseText) => {
+            let result400: any = null;
+            let resultData400 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result400 = ProblemDetails.fromJS(resultData400);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result400);
+            });
+        } else if (status === 500) {
+            return response.text().then((_responseText) => {
+            return throwException("A server side error occurred.", status, _responseText, _headers);
+            });
+        } else if (status === 401) {
+            return response.text().then((_responseText) => {
+            let result401: any = null;
+            let resultData401 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result401 = ProblemDetails.fromJS(resultData401);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result401);
+            });
+        } else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+            return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve<OscilloscopeDataResponse>(null as any);
+    }
+
+    /**
+     * 更新触发参数
+     * @param level (optional) 触发电平（0-255）
+     * @param risingEdge (optional) 触发边沿（true为上升沿，false为下降沿）
+     * @return 操作结果
+     */
+    updateTrigger(level: number | undefined, risingEdge: boolean | undefined): Promise<boolean> {
+        let url_ = this.baseUrl + "/api/OscilloscopeApi/UpdateTrigger?";
+        if (level === null)
+            throw new Error("The parameter 'level' cannot be null.");
+        else if (level !== undefined)
+            url_ += "level=" + encodeURIComponent("" + level) + "&";
+        if (risingEdge === null)
+            throw new Error("The parameter 'risingEdge' cannot be null.");
+        else if (risingEdge !== undefined)
+            url_ += "risingEdge=" + encodeURIComponent("" + risingEdge) + "&";
+        url_ = url_.replace(/[?&]$/, "");
+
+        let options_: RequestInit = {
+            method: "POST",
+            headers: {
+                "Accept": "application/json"
+            }
+        };
+
+        return this.http.fetch(url_, options_).then((_response: Response) => {
+            return this.processUpdateTrigger(_response);
+        });
+    }
+
+    protected processUpdateTrigger(response: Response): Promise<boolean> {
+        const status = response.status;
+        let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+            let result200: any = null;
+            let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = resultData200 !== undefined ? resultData200 : <any>null;
+    
+            return result200;
+            });
+        } else if (status === 400) {
+            return response.text().then((_responseText) => {
+            let result400: any = null;
+            let resultData400 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result400 = ProblemDetails.fromJS(resultData400);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result400);
+            });
+        } else if (status === 500) {
+            return response.text().then((_responseText) => {
+            return throwException("A server side error occurred.", status, _responseText, _headers);
+            });
+        } else if (status === 401) {
+            return response.text().then((_responseText) => {
+            let result401: any = null;
+            let resultData401 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result401 = ProblemDetails.fromJS(resultData401);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result401);
+            });
+        } else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+            return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve<boolean>(null as any);
+    }
+
+    /**
+     * 更新采样参数
+     * @param horizontalShift (optional) 水平偏移量（0-1023）
+     * @param decimationRate (optional) 抽样率（0-1023）
+     * @return 操作结果
+     */
+    updateSampling(horizontalShift: number | undefined, decimationRate: number | undefined): Promise<boolean> {
+        let url_ = this.baseUrl + "/api/OscilloscopeApi/UpdateSampling?";
+        if (horizontalShift === null)
+            throw new Error("The parameter 'horizontalShift' cannot be null.");
+        else if (horizontalShift !== undefined)
+            url_ += "horizontalShift=" + encodeURIComponent("" + horizontalShift) + "&";
+        if (decimationRate === null)
+            throw new Error("The parameter 'decimationRate' cannot be null.");
+        else if (decimationRate !== undefined)
+            url_ += "decimationRate=" + encodeURIComponent("" + decimationRate) + "&";
+        url_ = url_.replace(/[?&]$/, "");
+
+        let options_: RequestInit = {
+            method: "POST",
+            headers: {
+                "Accept": "application/json"
+            }
+        };
+
+        return this.http.fetch(url_, options_).then((_response: Response) => {
+            return this.processUpdateSampling(_response);
+        });
+    }
+
+    protected processUpdateSampling(response: Response): Promise<boolean> {
+        const status = response.status;
+        let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+            let result200: any = null;
+            let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = resultData200 !== undefined ? resultData200 : <any>null;
+    
+            return result200;
+            });
+        } else if (status === 400) {
+            return response.text().then((_responseText) => {
+            let result400: any = null;
+            let resultData400 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result400 = ProblemDetails.fromJS(resultData400);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result400);
+            });
+        } else if (status === 500) {
+            return response.text().then((_responseText) => {
+            return throwException("A server side error occurred.", status, _responseText, _headers);
+            });
+        } else if (status === 401) {
+            return response.text().then((_responseText) => {
+            let result401: any = null;
+            let resultData401 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result401 = ProblemDetails.fromJS(resultData401);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result401);
+            });
+        } else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+            return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve<boolean>(null as any);
+    }
+
+    /**
+     * 手动刷新RAM
+     * @return 操作结果
+     */
+    refreshRAM(): Promise<boolean> {
+        let url_ = this.baseUrl + "/api/OscilloscopeApi/RefreshRAM";
+        url_ = url_.replace(/[?&]$/, "");
+
+        let options_: RequestInit = {
+            method: "POST",
+            headers: {
+                "Accept": "application/json"
+            }
+        };
+
+        return this.http.fetch(url_, options_).then((_response: Response) => {
+            return this.processRefreshRAM(_response);
+        });
+    }
+
+    protected processRefreshRAM(response: Response): Promise<boolean> {
+        const status = response.status;
+        let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+            let result200: any = null;
+            let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = resultData200 !== undefined ? resultData200 : <any>null;
+    
+            return result200;
+            });
+        } else if (status === 400) {
+            return response.text().then((_responseText) => {
+            let result400: any = null;
+            let resultData400 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result400 = ProblemDetails.fromJS(resultData400);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result400);
+            });
+        } else if (status === 500) {
+            return response.text().then((_responseText) => {
+            return throwException("A server side error occurred.", status, _responseText, _headers);
+            });
+        } else if (status === 401) {
+            return response.text().then((_responseText) => {
+            let result401: any = null;
+            let resultData401 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+            result401 = ProblemDetails.fromJS(resultData401);
+            return throwException("A server side error occurred.", status, _responseText, _headers, result401);
+            });
         } else if (status !== 200 && status !== 204) {
             return response.text().then((_responseText) => {
             return throwException("An unexpected server error occurred.", status, _responseText, _headers);
@@ -4885,6 +5358,140 @@ export interface INetworkInterfaceDto {
     macAddress: string;
 }
 
+/** 示波器完整配置 */
+export class OscilloscopeFullConfig implements IOscilloscopeFullConfig {
+    /** 是否启动捕获 */
+    captureEnabled!: boolean;
+    /** 触发电平（0-255） */
+    triggerLevel!: number;
+    /** 触发边沿（true为上升沿，false为下降沿） */
+    triggerRisingEdge!: boolean;
+    /** 水平偏移量（0-1023） */
+    horizontalShift!: number;
+    /** 抽样率（0-1023） */
+    decimationRate!: number;
+    /** 是否自动刷新RAM */
+    autoRefreshRAM!: boolean;
+
+    constructor(data?: IOscilloscopeFullConfig) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(_data?: any) {
+        if (_data) {
+            this.captureEnabled = _data["captureEnabled"];
+            this.triggerLevel = _data["triggerLevel"];
+            this.triggerRisingEdge = _data["triggerRisingEdge"];
+            this.horizontalShift = _data["horizontalShift"];
+            this.decimationRate = _data["decimationRate"];
+            this.autoRefreshRAM = _data["autoRefreshRAM"];
+        }
+    }
+
+    static fromJS(data: any): OscilloscopeFullConfig {
+        data = typeof data === 'object' ? data : {};
+        let result = new OscilloscopeFullConfig();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["captureEnabled"] = this.captureEnabled;
+        data["triggerLevel"] = this.triggerLevel;
+        data["triggerRisingEdge"] = this.triggerRisingEdge;
+        data["horizontalShift"] = this.horizontalShift;
+        data["decimationRate"] = this.decimationRate;
+        data["autoRefreshRAM"] = this.autoRefreshRAM;
+        return data;
+    }
+}
+
+/** 示波器完整配置 */
+export interface IOscilloscopeFullConfig {
+    /** 是否启动捕获 */
+    captureEnabled: boolean;
+    /** 触发电平（0-255） */
+    triggerLevel: number;
+    /** 触发边沿（true为上升沿，false为下降沿） */
+    triggerRisingEdge: boolean;
+    /** 水平偏移量（0-1023） */
+    horizontalShift: number;
+    /** 抽样率（0-1023） */
+    decimationRate: number;
+    /** 是否自动刷新RAM */
+    autoRefreshRAM: boolean;
+}
+
+/** 示波器状态和数据 */
+export class OscilloscopeDataResponse implements IOscilloscopeDataResponse {
+    /** AD采样频率 */
+    adFrequency!: number;
+    /** AD采样幅度 */
+    adVpp!: number;
+    /** AD采样最大值 */
+    adMax!: number;
+    /** AD采样最小值 */
+    adMin!: number;
+    /** 波形数据（Base64编码） */
+    waveformData!: string;
+
+    constructor(data?: IOscilloscopeDataResponse) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    (<any>this)[property] = (<any>data)[property];
+            }
+        }
+    }
+
+    init(_data?: any) {
+        if (_data) {
+            this.adFrequency = _data["adFrequency"];
+            this.adVpp = _data["adVpp"];
+            this.adMax = _data["adMax"];
+            this.adMin = _data["adMin"];
+            this.waveformData = _data["waveformData"];
+        }
+    }
+
+    static fromJS(data: any): OscilloscopeDataResponse {
+        data = typeof data === 'object' ? data : {};
+        let result = new OscilloscopeDataResponse();
+        result.init(data);
+        return result;
+    }
+
+    toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        data["adFrequency"] = this.adFrequency;
+        data["adVpp"] = this.adVpp;
+        data["adMax"] = this.adMax;
+        data["adMin"] = this.adMin;
+        data["waveformData"] = this.waveformData;
+        return data;
+    }
+}
+
+/** 示波器状态和数据 */
+export interface IOscilloscopeDataResponse {
+    /** AD采样频率 */
+    adFrequency: number;
+    /** AD采样幅度 */
+    adVpp: number;
+    /** AD采样最大值 */
+    adMax: number;
+    /** AD采样最小值 */
+    adMin: number;
+    /** 波形数据（Base64编码） */
+    waveformData: string;
+}
+
 /** Package options which to send address to read or write */
 export class SendAddrPackOptions implements ISendAddrPackOptions {
     /** 突发类型 */

src/components/Oscilloscope/OscilloscopeManager.ts

@@ -0,0 +1,264 @@
+import { createInjectionState } from "@vueuse/core";
+import { shallowRef, reactive, ref, computed } from "vue";
+import { Mutex } from "async-mutex";
+import {
+  OscilloscopeFullConfig,
+  OscilloscopeDataResponse,
+} from "@/APIClient";
+import { AuthManager } from "@/utils/AuthManager";
+import { useAlertStore } from "@/components/Alert";
+import { useRequiredInjection } from "@/utils/Common";
+
+export type OscilloscopeDataType = {
+  x: number[];
+  y: number[] | number[][];
+  xUnit: "s" | "ms" | "us" | "ns";
+  yUnit: "V" | "mV" | "uV";
+  adFrequency: number;
+  adVpp: number;
+  adMax: number;
+  adMin: number;
+};
+
+// 默认配置
+const DEFAULT_CONFIG: OscilloscopeFullConfig = new OscilloscopeFullConfig({
+  captureEnabled: false,
+  triggerLevel: 128,
+  triggerRisingEdge: true,
+  horizontalShift: 0,
+  decimationRate: 0,
+  autoRefreshRAM: false,
+});
+
+// 采样频率常量（后端返回）
+const [useProvideOscilloscope, useOscilloscopeState] = createInjectionState(() => {
+  const oscData = shallowRef<OscilloscopeDataType>();
+  const alert = useRequiredInjection(useAlertStore);
+
+  // 互斥锁
+  const operationMutex = new Mutex();
+
+  // 状态
+  const isApplying = ref(false);
+  const isCapturing = ref(false);
+
+  // 配置
+  const config = reactive<OscilloscopeFullConfig>(new OscilloscopeFullConfig({ ...DEFAULT_CONFIG }));
+
+  // 采样点数（由后端数据决定）
+  const sampleCount = ref(0);
+
+  // 采样周期（ns），由adFrequency计算
+  const samplePeriodNs = computed(() =>
+    oscData.value?.adFrequency ? 1_000_000_000 / oscData.value.adFrequency : 200
+  );
+
+  // 应用配置
+  const applyConfiguration = async () => {
+    if (operationMutex.isLocked()) {
+      alert.warn("有其他操作正在进行中，请稍后再试", 3000);
+      return;
+    }
+    const release = await operationMutex.acquire();
+    isApplying.value = true;
+    try {
+      const client = AuthManager.createAuthenticatedOscilloscopeApiClient();
+      const success = await client.initialize({ ...config });
+      if (success) {
+        alert.success("示波器配置已应用", 2000);
+      } else {
+        throw new Error("应用失败");
+      }
+    } catch (error) {
+      alert.error("应用配置失败", 3000);
+    } finally {
+      isApplying.value = false;
+      release();
+    }
+  };
+
+  // 重置配置
+  const resetConfiguration = () => {
+    Object.assign(config, { ...DEFAULT_CONFIG });
+    alert.info("配置已重置", 2000);
+  };
+
+  // 获取数据
+  const getOscilloscopeData = async () => {
+    try {
+      const client = AuthManager.createAuthenticatedOscilloscopeApiClient();
+      const resp: OscilloscopeDataResponse = await client.getData();
+
+      // 解析波形数据
+      const binaryString = atob(resp.waveformData);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      sampleCount.value = bytes.length;
+
+      // 构建时间轴
+      const x = Array.from(
+        { length: bytes.length },
+        (_, i) => (i * samplePeriodNs.value) / 1000 // us
+      );
+      const y = Array.from(bytes);
+
+      oscData.value = {
+        x,
+        y,
+        xUnit: "us",
+        yUnit: "V",
+        adFrequency: resp.adFrequency,
+        adVpp: resp.adVpp,
+        adMax: resp.adMax,
+        adMin: resp.adMin,
+      };
+    } catch (error) {
+      alert.error("获取示波器数据失败", 3000);
+    }
+  };
+
+  // 启动捕获
+  const startCapture = async () => {
+    if (operationMutex.isLocked()) {
+      alert.warn("有其他操作正在进行中，请稍后再试", 3000);
+      return;
+    }
+    isCapturing.value = true;
+    const release = await operationMutex.acquire();
+    try {
+      const client = AuthManager.createAuthenticatedOscilloscopeApiClient();
+      const started = await client.startCapture();
+      if (!started) throw new Error("无法启动捕获");
+      alert.info("开始捕获...", 2000);
+
+      // 简单轮询，直到捕获完成（可根据后端实际情况优化）
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await getOscilloscopeData();
+      alert.success("捕获完成", 2000);
+    } catch (error) {
+      alert.error("捕获失败", 3000);
+    } finally {
+      isCapturing.value = false;
+      release();
+    }
+  };
+
+  // 停止捕获
+  const stopCapture = async () => {
+    if (!isCapturing.value) {
+      alert.warn("当前没有正在进行的捕获操作", 2000);
+      return;
+    }
+    isCapturing.value = false;
+    const release = await operationMutex.acquire();
+    try {
+      const client = AuthManager.createAuthenticatedOscilloscopeApiClient();
+      const stopped = await client.stopCapture();
+      if (!stopped) throw new Error("无法停止捕获");
+      alert.info("捕获已停止", 2000);
+    } catch (error) {
+      alert.error("停止捕获失败", 3000);
+    } finally {
+      release();
+    }
+  };
+
+  // 更新触发参数
+  const updateTrigger = async (level: number, risingEdge: boolean) => {
+    const client = AuthManager.createAuthenticatedOscilloscopeApiClient();
+    try {
+      const ok = await client.updateTrigger(level, risingEdge);
+      if (ok) {
+        config.triggerLevel = level;
+        config.triggerRisingEdge = risingEdge;
+        alert.success("触发参数已更新", 2000);
+      } else {
+        throw new Error();
+      }
+    } catch {
+      alert.error("更新触发参数失败", 2000);
+    }
+  };
+
+  // 更新采样参数
+  const updateSampling = async (horizontalShift: number, decimationRate: number) => {
+    const client = AuthManager.createAuthenticatedOscilloscopeApiClient();
+    try {
+      const ok = await client.updateSampling(horizontalShift, decimationRate);
+      if (ok) {
+        config.horizontalShift = horizontalShift;
+        config.decimationRate = decimationRate;
+        alert.success("采样参数已更新", 2000);
+      } else {
+        throw new Error();
+      }
+    } catch {
+      alert.error("更新采样参数失败", 2000);
+    }
+  };
+
+  // 手动刷新RAM
+  const refreshRAM = async () => {
+    const client = AuthManager.createAuthenticatedOscilloscopeApiClient();
+    try {
+      const ok = await client.refreshRAM();
+      if (ok) {
+        alert.success("RAM已刷新", 2000);
+      } else {
+        throw new Error();
+      }
+    } catch {
+      alert.error("刷新RAM失败", 2000);
+    }
+  };
+
+  // 生成测试数据
+  const generateTestData = () => {
+    const freq = 5_000_000;
+    const duration = 0.001; // 1ms
+    const points = Math.floor(freq * duration);
+    const x = Array.from({ length: points }, (_, i) => (i * 1_000_000_000 / freq) / 1000);
+    const y = Array.from({ length: points }, (_, i) =>
+      Math.floor(Math.sin(i * 0.01) * 127 + 128)
+    );
+    oscData.value = {
+      x,
+      y,
+      xUnit: "us",
+      yUnit: "V",
+      adFrequency: freq,
+      adVpp: 2.0,
+      adMax: 255,
+      adMin: 0,
+    };
+    alert.success("测试数据生成成功", 2000);
+  };
+
+  const isOperationInProgress = computed(
+    () => isApplying.value || isCapturing.value || operationMutex.isLocked()
+  );
+
+  return {
+    oscData,
+    config,
+    isApplying,
+    isCapturing,
+    isOperationInProgress,
+    sampleCount,
+    samplePeriodNs,
+
+    applyConfiguration,
+    resetConfiguration,
+    getOscilloscopeData,
+    startCapture,
+    stopCapture,
+    updateTrigger,
+    updateSampling,
+    refreshRAM,
+    generateTestData,
+  };
+});
+
+export { useProvideOscilloscope, useOscilloscopeState, DEFAULT_CONFIG };

src/components/Oscilloscope/OscilloscopeWaveformDisplay.vue

@@ -1,6 +1,6 @@
 <template>
   <div class="w-full h-100">
-    <v-chart v-if="true" class="w-full h-full" :option="option" autoresize />
+    <v-chart v-if="hasData" class="w-full h-full" :option="option" autoresize />
     <div
       v-else
       class="w-full h-full flex items-center justify-center text-gray-500"
@@ -11,16 +11,15 @@
 </template>
 
 <script setup lang="ts">
-import { computed, withDefaults } from "vue";
+import { computed } from "vue";
 import { forEach } from "lodash";
 import VChart from "vue-echarts";
-import { type WaveformDataType } from "./index";
+import { useOscilloscopeState } from "./OscilloscopeManager";
 
 // Echarts
 import { use } from "echarts/core";
 import { LineChart } from "echarts/charts";
 import {
-  TitleComponent,
   TooltipComponent,
   LegendComponent,
   ToolboxComponent,
@@ -37,6 +36,7 @@ import type {
   DataZoomComponentOption,
   GridComponentOption,
 } from "echarts/components";
+import { useRequiredInjection } from "@/utils/Common";
 
 use([
   TooltipComponent,
@@ -57,44 +57,47 @@ type EChartsOption = ComposeOption<
   | LineSeriesOption
 >;
 
-const props = withDefaults(
-  defineProps<{
-    data?: WaveformDataType;
-  }>(),
-  {
-    data: () => ({
-      x: [],
-      y: [],
-      xUnit: "s",
-      yUnit: "V",
-    }),
-  },
-);
+// 使用 manager 获取 oscilloscope 数据
+const { oscData } = useRequiredInjection(useOscilloscopeState);
 
 const hasData = computed(() => {
   return (
-    props.data &&
-    props.data.x &&
-    props.data.y &&
-    props.data.x.length > 0 &&
-    props.data.y.length > 0 &&
-    props.data.y.some((channel) => channel.length > 0)
+    oscData.value &&
+    oscData.value.x &&
+    oscData.value.y &&
+    oscData.value.x.length > 0 &&
+    (
+      Array.isArray(oscData.value.y[0])
+        ? oscData.value.y.some((channel: any) => channel.length > 0)
+        : oscData.value.y.length > 0
+    )
   );
 });
 
 const option = computed((): EChartsOption => {
+  if (!oscData.value || !oscData.value.x || !oscData.value.y) {
+    return {};
+  }
+
   const series: LineSeriesOption[] = [];
 
-  forEach(props.data.y, (yData, index) => {
-    // 将 x 和 y 数据组合成 [x, y] 格式
-    const seriesData = props.data.x.map((xValue, i) => [xValue, yData[i] || 0]);
+  // 兼容单通道和多通道，确保 yChannels 为 number[][]
+  const yChannels: number[][] = Array.isArray(oscData.value.y[0])
+    ? (oscData.value.y as number[][])
+    : [oscData.value.y as number[]];
 
+  forEach(yChannels, (yData, index) => {
+    if (!oscData.value || !yData) return;
+    const seriesData = oscData.value.x.map((xValue, i) => [
+      xValue,
+      yData && yData[i] !== undefined ? yData[i] : 0,
+    ]);
     series.push({
       type: "line",
       name: `通道 ${index + 1}`,
       data: seriesData,
-      smooth: false, // 示波器通常显示原始波形
-      symbol: "none", // 不显示数据点标记
+      smooth: false,
+      symbol: "none",
       lineStyle: {
         width: 2,
       },
@@ -111,9 +114,10 @@ const option = computed((): EChartsOption => {
     tooltip: {
       trigger: "axis",
       formatter: (params: any) => {
-        let result = `时间: ${params[0].data[0].toFixed(2)} ${props.data.xUnit}<br/>`;
+        if (!oscData.value) return "";
+        let result = `时间: ${params[0].data[0].toFixed(2)} ${oscData.value.xUnit}<br/>`;
         params.forEach((param: any) => {
-          result += `${param.seriesName}: ${param.data[1].toFixed(3)} ${props.data.yUnit}<br/>`;
+          result += `${param.seriesName}: ${param.data[1].toFixed(3)} ${oscData.value?.yUnit ?? ""}<br/>`;
         });
         return result;
       },
@@ -141,7 +145,7 @@ const option = computed((): EChartsOption => {
     ],
     xAxis: {
       type: "value",
-      name: `时间 (${props.data.xUnit})`,
+      name: oscData.value ? `时间 (${oscData.value.xUnit})` : "时间",
       nameLocation: "middle",
       nameGap: 30,
       axisLine: {
@@ -156,7 +160,7 @@ const option = computed((): EChartsOption => {
     },
     yAxis: {
       type: "value",
-      name: `电压 (${props.data.yUnit})`,
+      name: oscData.value ? `电压 (${oscData.value.yUnit})` : "电压",
       nameLocation: "middle",
       nameGap: 40,
       axisLine: {

src/components/Oscilloscope/index.ts

@@ -1,42 +1,3 @@
-import WaveformDisplay from "./WaveformDisplay.vue";
+import OscilloscopeWaveformDisplay from "./OscilloscopeWaveformDisplay.vue";
 
-type WaveformDataType = {
-  x: number[];
-  y: number[][];
-  xUnit: "s" | "ms" | "us";
-  yUnit: "V" | "mV" | "uV";
-};
-
-// Test data generator
-function generateTestData(): WaveformDataType {
-  const sampleRate = 1000; // 1kHz
-  const duration = 0.1; // 10ms
-  const points = Math.floor(sampleRate * duration);
-
-  const x = Array.from({ length: points }, (_, i) => (i / sampleRate) * 1000); // time in ms
-
-  // Generate multiple channels with different waveforms
-  const y = [
-    // Channel 1: Sine wave 50Hz
-    Array.from(
-      { length: points },
-      (_, i) => Math.sin((2 * Math.PI * 50 * i) / sampleRate) * 3.3,
-    ),
-    // Channel 2: Square wave 25Hz
-    Array.from(
-      { length: points },
-      (_, i) => Math.sign(Math.sin((2 * Math.PI * 25 * i) / sampleRate)) * 5,
-    ),
-    // Channel 3: Sawtooth wave 33Hz
-    Array.from(
-      { length: points },
-      (_, i) => (2 * (((33 * i) / sampleRate) % 1) - 1) * 2.5,
-    ),
-    // Channel 4: Noise + DC offset
-    Array.from({ length: points }, () => Math.random() * 0.5 + 1.5),
-  ];
-
-  return { x, y, xUnit: "ms", yUnit: "V" };
-}
-
-export { WaveformDisplay, generateTestData , type WaveformDataType };
+export { OscilloscopeWaveformDisplay };

src/utils/AuthManager.ts

@@ -11,6 +11,7 @@ import {
   UDPClient,
   LogicAnalyzerClient,
   NetConfigClient,
+  OscilloscopeApiClient,
 } from "@/APIClient";
 
 // 支持的客户端类型联合类型
@@ -26,7 +27,8 @@ type SupportedClient =
   | TutorialClient
   | LogicAnalyzerClient
   | UDPClient
-  | NetConfigClient;
+  | NetConfigClient
+  | OscilloscopeApiClient;
 
 export class AuthManager {
   // 存储token到localStorage
@@ -158,10 +160,14 @@ export class AuthManager {
   public static createAuthenticatedLogicAnalyzerClient(): LogicAnalyzerClient {
     return AuthManager.createAuthenticatedClient(LogicAnalyzerClient);
   }
-  
+
   public static createAuthenticatedNetConfigClient(): NetConfigClient {
     return AuthManager.createAuthenticatedClient(NetConfigClient);
   }
+  
+  public static createAuthenticatedOscilloscopeApiClient(): OscilloscopeApiClient {
+    return AuthManager.createAuthenticatedClient(OscilloscopeApiClient);
+  }
 
   // 登录函数
   public static async login(

src/views/Project/BottomBar.vue

@@ -104,9 +104,12 @@ import { onMounted, ref, watch } from "vue";
 import Debugger from "./Debugger.vue";
 import { useProvideLogicAnalyzer } from "@/components/LogicAnalyzer";
 import { useProvideWaveformManager } from "@/components/WaveformDisplay/WaveformManager";
+import { useProvideOscilloscope } from "@/components/Oscilloscope/OscilloscopeManager";
 
 const analyzer = useProvideLogicAnalyzer();
 const waveformManager = useProvideWaveformManager();
+const oscilloscopeManager = useProvideOscilloscope();
+
 waveformManager.logicData.value = waveformManager.generateTestData();
 
 const checkID = useLocalStorage("checkID", 1);

src/views/Project/Oscilloscope.vue

@@ -7,7 +7,7 @@
           <Activity class="w-5 h-5" />
           波形显示
         </h2>
-        <WaveformDisplay :data="generateTestData()" />
+        <OscilloscopeWaveformDisplay />
       </div>
     </div>
   </div>
@@ -15,7 +15,7 @@
 
 <script setup lang="ts">
 import { Activity } from "lucide-vue-next";
-import { WaveformDisplay, generateTestData } from "@/components/Oscilloscope";
+import { OscilloscopeWaveformDisplay } from "@/components/Oscilloscope";
 import { useEquipments } from "@/stores/equipments";
 
 // 使用全局设备配置