siglent-sdg-mcp 1.0.0

package/build/connection.js

@@ -0,0 +1,252 @@
+import * as net from "node:net";
+const DEFAULT_PORT = 5025;
+const DEFAULT_TIMEOUT = 5000;
+const BINARY_TIMEOUT = 30000;
+export class SiglentConnection {
+    socket = null;
+    host = "";
+    port = DEFAULT_PORT;
+    dataBuffer = Buffer.alloc(0);
+    responseResolve = null;
+    responseReject = null;
+    responseTimer = null;
+    expectedBinaryLength = null;
+    binaryDataStart = 0;
+    headerParsed = false;
+    queryQueue = [];
+    queryRunning = false;
+    async connect(host, port = DEFAULT_PORT) {
+        if (this.socket) {
+            this.disconnect();
+        }
+        this.host = host;
+        this.port = port;
+        return new Promise((resolve, reject) => {
+            const socket = new net.Socket();
+            const connectTimeout = setTimeout(() => {
+                socket.destroy();
+                reject(new Error(`Connection timeout to ${host}:${port}`));
+            }, 5000);
+            socket.on("connect", async () => {
+                clearTimeout(connectTimeout);
+                socket.removeAllListeners("error");
+                this.socket = socket;
+                this.setupSocketListeners();
+                try {
+                    // Drain any welcome banner
+                    await this.delay(200);
+                    this.dataBuffer = Buffer.alloc(0);
+                    // Try to set CHDR OFF for clean responses (not all SDG models support it)
+                    try {
+                        await this.sendCommand("CHDR OFF");
+                        await this.delay(100);
+                    }
+                    catch {
+                        // Some models don't support CHDR — that's OK
+                    }
+                    // Query identification
+                    const idn = await this.query("*IDN?");
+                    resolve(idn);
+                }
+                catch (err) {
+                    this.disconnect();
+                    reject(new Error(`Connected but failed to initialize: ${err instanceof Error ? err.message : String(err)}`));
+                }
+            });
+            socket.on("error", (err) => {
+                clearTimeout(connectTimeout);
+                reject(new Error(`Connection failed: ${err.message}`));
+            });
+            socket.connect(port, host);
+        });
+    }
+    disconnect() {
+        const pending = this.queryQueue.splice(0);
+        this.queryRunning = false;
+        if (this.responseReject) {
+            this.responseReject(new Error("Connection closed"));
+        }
+        this.clearPending();
+        for (const q of pending) {
+            q.reject(new Error("Connection closed"));
+        }
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = null;
+        }
+        this.dataBuffer = Buffer.alloc(0);
+    }
+    isConnected() {
+        return this.socket !== null && !this.socket.destroyed;
+    }
+    getConnectionInfo() {
+        if (!this.isConnected())
+            return "Not connected";
+        return `${this.host}:${this.port}`;
+    }
+    async sendCommand(cmd) {
+        this.ensureConnected();
+        return new Promise((resolve, reject) => {
+            this.socket.write(cmd + "\n", (err) => {
+                if (err)
+                    reject(new Error(`Write failed: ${err.message}`));
+                else
+                    resolve();
+            });
+        });
+    }
+    async query(cmd, timeout = DEFAULT_TIMEOUT) {
+        this.ensureConnected();
+        const buf = await this.enqueueQuery(cmd, false, timeout);
+        return buf.toString("utf-8").trim();
+    }
+    async queryBinary(cmd, timeout = BINARY_TIMEOUT) {
+        this.ensureConnected();
+        return this.enqueueQuery(cmd, true, timeout);
+    }
+    enqueueQuery(cmd, binary, timeout) {
+        return new Promise((resolve, reject) => {
+            this.queryQueue.push({ cmd, binary, timeout, resolve, reject });
+            this.drainQueue();
+        });
+    }
+    drainQueue() {
+        if (this.queryRunning || this.queryQueue.length === 0)
+            return;
+        this.queryRunning = true;
+        const { cmd, binary, timeout, resolve, reject } = this.queryQueue.shift();
+        this.expectedBinaryLength = null;
+        this.binaryDataStart = 0;
+        this.headerParsed = false;
+        this.dataBuffer = Buffer.alloc(0);
+        this.responseResolve = (buf) => {
+            this.queryRunning = false;
+            resolve(buf);
+            this.drainQueue();
+        };
+        this.responseReject = (err) => {
+            this.queryRunning = false;
+            reject(err);
+            this.drainQueue();
+        };
+        this.responseTimer = setTimeout(() => {
+            this.clearPending();
+            const err = new Error(`${binary ? "Binary query" : "Query"} timeout after ${timeout}ms for command: ${cmd}`);
+            this.queryRunning = false;
+            reject(err);
+            this.drainQueue();
+        }, timeout);
+        this.socket.write(cmd + "\n", (err) => {
+            if (err) {
+                this.clearPending();
+                this.queryRunning = false;
+                reject(new Error(`Write failed: ${err.message}`));
+                this.drainQueue();
+            }
+        });
+    }
+    setupSocketListeners() {
+        this.socket.on("data", (chunk) => {
+            this.dataBuffer = Buffer.concat([this.dataBuffer, chunk]);
+            this.tryResolve();
+        });
+        this.socket.on("close", () => {
+            const pending = this.queryQueue.splice(0);
+            this.queryRunning = false;
+            if (this.responseReject) {
+                this.responseReject(new Error("Connection closed unexpectedly"));
+            }
+            this.clearPending();
+            for (const q of pending) {
+                q.reject(new Error("Connection closed unexpectedly"));
+            }
+            this.socket = null;
+        });
+        this.socket.on("error", (err) => {
+            if (this.responseReject) {
+                this.responseReject(new Error(`Socket error: ${err.message}`));
+            }
+            this.clearPending();
+        });
+    }
+    tryResolve() {
+        if (!this.responseResolve)
+            return;
+        // Try to detect binary framing format
+        if (!this.headerParsed && this.dataBuffer.length >= 6) {
+            // Check for raw BMP: starts with "BM" magic bytes
+            if (this.dataBuffer[0] === 0x42 && this.dataBuffer[1] === 0x4d) {
+                const bmpSize = this.dataBuffer.readUInt32LE(2);
+                if (bmpSize > 0 && bmpSize < 100_000_000) {
+                    this.expectedBinaryLength = bmpSize;
+                    this.binaryDataStart = 0;
+                    this.headerParsed = true;
+                }
+            }
+            // Check for IEEE 488.2 definite length block: #<digitCount><digits><data>
+            if (!this.headerParsed) {
+                const hashIndex = this.dataBuffer.indexOf(0x23); // '#'
+                if (hashIndex >= 0 && hashIndex + 2 <= this.dataBuffer.length) {
+                    const digitCount = this.dataBuffer[hashIndex + 1] - 0x30;
+                    if (digitCount >= 1 && digitCount <= 9) {
+                        const headerSize = 2 + digitCount;
+                        if (hashIndex + headerSize <= this.dataBuffer.length) {
+                            const lengthStr = this.dataBuffer
+                                .subarray(hashIndex + 2, hashIndex + headerSize)
+                                .toString("ascii");
+                            const dataLength = parseInt(lengthStr, 10);
+                            if (!isNaN(dataLength) && dataLength > 0) {
+                                this.expectedBinaryLength = dataLength;
+                                this.binaryDataStart = hashIndex + headerSize;
+                                this.headerParsed = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (this.expectedBinaryLength !== null && this.headerParsed) {
+            const trailingBytes = this.binaryDataStart === 0 ? 1 : 2;
+            const totalExpected = this.binaryDataStart + this.expectedBinaryLength + trailingBytes;
+            if (this.dataBuffer.length >= totalExpected) {
+                const binaryData = this.dataBuffer.subarray(this.binaryDataStart, this.binaryDataStart + this.expectedBinaryLength);
+                const resolve = this.responseResolve;
+                this.clearPending();
+                resolve(Buffer.from(binaryData));
+            }
+        }
+        else {
+            // Text mode: look for newline terminator
+            const newlineIndex = this.dataBuffer.indexOf(0x0a);
+            if (newlineIndex >= 0) {
+                const response = this.dataBuffer.subarray(0, newlineIndex);
+                const resolve = this.responseResolve;
+                this.clearPending();
+                resolve(Buffer.from(response));
+            }
+        }
+    }
+    clearPending() {
+        if (this.responseTimer) {
+            clearTimeout(this.responseTimer);
+            this.responseTimer = null;
+        }
+        this.responseResolve = null;
+        this.responseReject = null;
+        this.expectedBinaryLength = null;
+        this.binaryDataStart = 0;
+        this.headerParsed = false;
+    }
+    ensureConnected() {
+        if (!this.isConnected()) {
+            throw new Error("Not connected to waveform generator. Use the 'connect' tool first.");
+        }
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+// Singleton instance
+export const connection = new SiglentConnection();
+//# sourceMappingURL=connection.js.map

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerConnectionTools } from "./tools/connection.js";
+import { registerOutputTools } from "./tools/output.js";
+import { registerBasicWaveTools } from "./tools/basic-wave.js";
+import { registerModulationTools } from "./tools/modulation.js";
+import { registerSweepTools } from "./tools/sweep.js";
+import { registerBurstTools } from "./tools/burst.js";
+import { registerArbitraryTools } from "./tools/arbitrary.js";
+import { registerUtilityTools } from "./tools/utility.js";
+import { registerScpiTools } from "./tools/scpi.js";
+import { connection } from "./connection.js";
+// Prevent uncaught errors from killing the MCP server process
+process.on("uncaughtException", (err) => {
+    console.error("Uncaught exception:", err);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error("Unhandled rejection:", reason);
+});
+const server = new McpServer({
+    name: "siglent-sdg-mcp",
+    version: "1.0.0",
+});
+// Register all tool groups
+registerConnectionTools(server);
+registerOutputTools(server);
+registerBasicWaveTools(server);
+registerModulationTools(server);
+registerSweepTools(server);
+registerBurstTools(server);
+registerArbitraryTools(server);
+registerUtilityTools(server);
+registerScpiTools(server);
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("siglent-sdg-mcp server running on stdio");
+    // Auto-connect if env var is set (fire-and-forget, don't block MCP startup)
+    const autoIp = process.env.SIGLENT_SDG_IP || process.env.SIGLENT_IP;
+    if (autoIp) {
+        const port = parseInt(process.env.SIGLENT_SDG_PORT || process.env.SIGLENT_PORT || "5025", 10);
+        connection.connect(autoIp, port).then((idn) => console.error(`Auto-connected to ${autoIp}: ${idn}`), (err) => {
+            console.error(`Auto-connect to ${autoIp} failed: ${err instanceof Error ? err.message : String(err)}`);
+            console.error("Use the 'connect' tool to connect manually.");
+        });
+    }
+}
+main().catch((error) => {
+    console.error("Startup error:", error);
+});
+//# sourceMappingURL=index.js.map

package/build/tools/arbitrary.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerArbitraryTools(server: McpServer): void;

package/build/tools/arbitrary.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { connection } from "../connection.js";
+export function registerArbitraryTools(server) {
+    server.tool("get_arbitrary_wave", "Get the current arbitrary waveform selection for a channel. Returns the waveform index and name.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to query"),
+    }, { readOnlyHint: true }, async ({ channel }) => {
+        try {
+            const response = await connection.query(`${channel}:ARWV?`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("set_arbitrary_wave", "Set the arbitrary waveform for a channel by index number or by name. Use index for built-in waveforms (e.g. 2=StairUp, 18=Sinc, 26=Cardiac) or name for user-defined waveforms.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to configure"),
+        index: z
+            .number()
+            .optional()
+            .describe("Index of the built-in arbitrary waveform (0-198). Examples: 0=Sine, 2=StairUp, 10=ExpFal, 18=Sinc, 19=Gaussian, 26=Cardiac"),
+        name: z
+            .string()
+            .optional()
+            .describe('Name of the waveform (for user-defined waves, use quotes). Can also be a path like "Local/wave1.bin"'),
+    }, { readOnlyHint: false }, async ({ channel, index, name }) => {
+        try {
+            if (index === undefined && !name) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: Either 'index' or 'name' must be specified.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            let cmd;
+            if (index !== undefined) {
+                cmd = `${channel}:ARWV INDEX,${index}`;
+            }
+            else {
+                cmd = `${channel}:ARWV NAME,"${name}"`;
+            }
+            await connection.sendCommand(cmd);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Arbitrary wave set: ${cmd}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=arbitrary.js.map

package/build/tools/basic-wave.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerBasicWaveTools(server: McpServer): void;

package/build/tools/basic-wave.js

@@ -0,0 +1,172 @@
+import { z } from "zod";
+import { connection } from "../connection.js";
+export function registerBasicWaveTools(server) {
+    server.tool("get_basic_wave", "Get the basic waveform parameters of a channel, including waveform type, frequency, amplitude, offset, phase, duty cycle, etc.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to query"),
+    }, { readOnlyHint: true }, async ({ channel }) => {
+        try {
+            const response = await connection.query(`${channel}:BSWV?`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("configure_basic_wave", "Configure the basic waveform parameters of a channel. Multiple parameters can be set in a single call. The command builds a single BSWV command with all specified parameters.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to configure"),
+        waveform_type: z
+            .enum(["SINE", "SQUARE", "RAMP", "PULSE", "NOISE", "ARB", "DC", "PRBS"])
+            .optional()
+            .describe("Waveform type"),
+        frequency: z
+            .number()
+            .optional()
+            .describe("Frequency in Hz (not valid for NOISE or DC)"),
+        period: z
+            .number()
+            .optional()
+            .describe("Period in seconds (alternative to frequency)"),
+        amplitude: z
+            .number()
+            .optional()
+            .describe("Amplitude in Vpp (not valid for NOISE or DC)"),
+        amplitude_vrms: z
+            .number()
+            .optional()
+            .describe("Amplitude in Vrms"),
+        offset: z
+            .number()
+            .optional()
+            .describe("DC offset in volts (not valid for NOISE)"),
+        phase: z
+            .number()
+            .optional()
+            .describe("Phase in degrees (0-360, not valid for NOISE, PULSE, or DC)"),
+        duty: z
+            .number()
+            .optional()
+            .describe("Duty cycle in % (only for SQUARE or PULSE)"),
+        symmetry: z
+            .number()
+            .optional()
+            .describe("Symmetry in % (0-100, only for RAMP)"),
+        width: z
+            .number()
+            .optional()
+            .describe("Pulse width in seconds (only for PULSE)"),
+        rise: z
+            .number()
+            .optional()
+            .describe("Rise time in seconds (only for PULSE)"),
+        fall: z
+            .number()
+            .optional()
+            .describe("Fall time in seconds (only for PULSE)"),
+        delay: z
+            .number()
+            .optional()
+            .describe("Waveform delay in seconds"),
+        stdev: z
+            .number()
+            .optional()
+            .describe("Standard deviation in volts (only for NOISE)"),
+        mean: z
+            .number()
+            .optional()
+            .describe("Mean in volts (only for NOISE)"),
+        high_level: z
+            .number()
+            .optional()
+            .describe("High level in volts"),
+        low_level: z
+            .number()
+            .optional()
+            .describe("Low level in volts"),
+    }, { readOnlyHint: false }, async ({ channel, waveform_type, frequency, period, amplitude, amplitude_vrms, offset, phase, duty, symmetry, width, rise, fall, delay, stdev, mean, high_level, low_level, }) => {
+        try {
+            const parts = [];
+            if (waveform_type)
+                parts.push(`WVTP,${waveform_type}`);
+            if (frequency !== undefined)
+                parts.push(`FRQ,${frequency}`);
+            if (period !== undefined)
+                parts.push(`PERI,${period}`);
+            if (amplitude !== undefined)
+                parts.push(`AMP,${amplitude}`);
+            if (amplitude_vrms !== undefined)
+                parts.push(`AMPVRMS,${amplitude_vrms}`);
+            if (offset !== undefined)
+                parts.push(`OFST,${offset}`);
+            if (phase !== undefined)
+                parts.push(`PHSE,${phase}`);
+            if (duty !== undefined)
+                parts.push(`DUTY,${duty}`);
+            if (symmetry !== undefined)
+                parts.push(`SYM,${symmetry}`);
+            if (width !== undefined)
+                parts.push(`WIDTH,${width}`);
+            if (rise !== undefined)
+                parts.push(`RISE,${rise}`);
+            if (fall !== undefined)
+                parts.push(`FALL,${fall}`);
+            if (delay !== undefined)
+                parts.push(`DLY,${delay}`);
+            if (stdev !== undefined)
+                parts.push(`STDEV,${stdev}`);
+            if (mean !== undefined)
+                parts.push(`MEAN,${mean}`);
+            if (high_level !== undefined)
+                parts.push(`HLEV,${high_level}`);
+            if (low_level !== undefined)
+                parts.push(`LLEV,${low_level}`);
+            if (parts.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: At least one parameter must be specified.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const cmd = `${channel}:BSWV ${parts.join(",")}`;
+            await connection.sendCommand(cmd);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Basic wave configured: ${cmd}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=basic-wave.js.map

package/build/tools/burst.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerBurstTools(server: McpServer): void;